sumologic-query 1.3.1 → 1.3.3

data/lib/sumologic/http/client.rb

@@ -1,30 +1,41 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'json'
-require 'uri'
 require_relative 'connection_pool'
+require_relative 'debug_logger'
+require_relative 'cookie_jar'
+require_relative 'request_builder'
+require_relative 'response_handler'
 
 module Sumologic
   module Http
-    # Handles HTTP communication with Sumo Logic API
-    # Responsibilities: request execution, error handling, SSL configuration
-    # Uses connection pooling for thread-safe parallel requests
+    # Orchestrates HTTP communication with Sumo Logic API
+    # Delegates to specialized components for request building,
+    # response handling, connection pooling, and cookie management
     class Client
       def initialize(base_url:, authenticator:)
-        @base_url = base_url
-        @authenticator = authenticator
+        @cookie_jar = CookieJar.new
+        @request_builder = RequestBuilder.new(
+          base_url: base_url,
+          authenticator: authenticator,
+          cookie_jar: @cookie_jar
+        )
+        @response_handler = ResponseHandler.new
         @connection_pool = ConnectionPool.new(base_url: base_url, max_connections: 10)
       end
 
       # Execute HTTP request with error handling
       # Uses connection pool for thread-safe parallel execution
       def request(method:, path:, body: nil, query_params: nil)
-        uri = build_uri(path, query_params)
-        request = build_request(method, uri, body)
+        uri = @request_builder.build_uri(path, query_params)
+        request = @request_builder.build_request(method, uri, body)
+
+        DebugLogger.log_request(method, uri, body)
 
         response = execute_request(uri, request)
-        handle_response(response)
+
+        DebugLogger.log_response(response)
+
+        @response_handler.handle(response)
       rescue Errno::ECONNRESET, Errno::EPIPE, EOFError, Net::HTTPBadResponse => e
         # Connection error - raise for retry at higher level
         raise Error, "Connection error: #{e.message}"
@@ -37,49 +48,15 @@ module Sumologic
 
       private
 
-      def build_uri(path, query_params)
-        uri = URI("#{@base_url}#{path}")
-        uri.query = URI.encode_www_form(query_params) if query_params
-        uri
-      end
-
-      def build_request(method, uri, body)
-        request_class = case method
-                        when :get then Net::HTTP::Get
-                        when :post then Net::HTTP::Post
-                        when :delete then Net::HTTP::Delete
-                        else raise ArgumentError, "Unsupported HTTP method: #{method}"
-                        end
-
-        request = request_class.new(uri)
-        request['Authorization'] = @authenticator.auth_header
-        request['Accept'] = 'application/json'
-
-        if body
-          request['Content-Type'] = 'application/json'
-          request.body = body.to_json
-        end
-
-        request
-      end
-
       def execute_request(uri, request)
-        @connection_pool.with_connection(uri) do |http|
+        response = @connection_pool.with_connection(uri) do |http|
           http.request(request)
         end
-      end
 
-      def handle_response(response)
-        case response.code.to_i
-        when 200..299
-          JSON.parse(response.body)
-        when 401, 403
-          raise AuthenticationError, "Authentication failed: #{response.body}"
-        when 429
-          raise Error, "Rate limit exceeded: #{response.body}"
-        else
-          raise Error, "HTTP #{response.code}: #{response.body}"
-        end
+        # Store cookies from response for subsequent requests
+        @cookie_jar.store_from_response(response)
+
+        response
       end
     end
   end

data/lib/sumologic/http/connection_pool.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'openssl'
+
 module Sumologic
   module Http
     # Thread-safe connection pool for HTTP clients
@@ -84,10 +86,22 @@ module Sumologic
         http.read_timeout = READ_TIMEOUT
         http.open_timeout = OPEN_TIMEOUT
         http.keep_alive_timeout = 30
+
+        # SSL configuration
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.cert_store = ssl_cert_store
+
         http.start
         http
       end
 
+      def ssl_cert_store
+        # Use system's default certificate store
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths
+        store
+      end
+
       def create_temporary_connection(uri)
         # Fallback: create a temporary connection if pool is exhausted
         create_connection(uri)

data/lib/sumologic/http/cookie_jar.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sumologic
+  module Http
+    # Simple cookie jar for storing and managing HTTP cookies
+    # Handles Set-Cookie response headers and Cookie request headers
+    class CookieJar
+      def initialize
+        @cookies = {}
+      end
+
+      # Store cookies from response Set-Cookie headers
+      def store_from_response(response)
+        return unless response['Set-Cookie']
+
+        Array(response['Set-Cookie']).each do |cookie_header|
+          parse_and_store(cookie_header)
+        end
+      end
+
+      # Format cookies for Cookie request header
+      # Returns nil if no cookies stored
+      def to_header
+        return nil if @cookies.empty?
+
+        @cookies.map { |name, value| "#{name}=#{value}" }.join('; ')
+      end
+
+      # Check if any cookies are stored
+      def any?
+        @cookies.any?
+      end
+
+      # Clear all stored cookies
+      def clear
+        @cookies.clear
+      end
+
+      private
+
+      def parse_and_store(cookie_header)
+        # Parse cookie name=value (ignore path, domain, expires, etc.)
+        # Example: "session_id=abc123; Path=/; HttpOnly"
+        return unless cookie_header =~ /^([^=]+)=([^;]+)/
+
+        name = Regexp.last_match(1).strip
+        value = Regexp.last_match(2).strip
+        @cookies[name] = value
+      end
+    end
+  end
+end

data/lib/sumologic/http/debug_logger.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Sumologic
+  module Http
+    # Handles debug logging for HTTP requests and responses
+    # Only logs when $DEBUG is enabled
+    module DebugLogger
+      module_function
+
+      def log_request(method, uri, body)
+        return unless $DEBUG
+
+        warn "\n[DEBUG] API Request:"
+        warn "  Method: #{method.to_s.upcase}"
+        warn "  URL: #{uri}"
+        log_request_body(body) if body
+        warn ''
+      end
+
+      def log_response(response)
+        return unless $DEBUG
+
+        warn '[DEBUG] API Response:'
+        warn "  Status: #{response.code} #{response.message}"
+        log_response_body(response.body)
+        warn ''
+      end
+
+      def log_request_body(body)
+        warn "  Body: #{JSON.pretty_generate(body)}"
+      rescue JSON::GeneratorError
+        warn "  Body: #{body.inspect}"
+      end
+
+      def log_response_body(body)
+        truncated = body.length > 500
+        display_body = truncated ? "#{body[0..500]}..." : body
+        warn "  Body: #{display_body}"
+        warn "  (truncated, full length: #{body.length} characters)" if truncated
+      end
+    end
+  end
+end

data/lib/sumologic/http/request_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Sumologic
+  module Http
+    # Builds HTTP requests with proper headers, authentication, and cookies
+    class RequestBuilder
+      def initialize(base_url:, authenticator:, cookie_jar:)
+        @base_url = base_url
+        @authenticator = authenticator
+        @cookie_jar = cookie_jar
+      end
+
+      # Build complete URI from path and query parameters
+      def build_uri(path, query_params = nil)
+        uri = URI("#{@base_url}#{path}")
+        uri.query = URI.encode_www_form(query_params) if query_params
+        uri
+      end
+
+      # Build HTTP request with all necessary headers
+      def build_request(method, uri, body = nil)
+        request = create_request_object(method, uri)
+        add_headers(request)
+        add_body(request, body) if body
+        request
+      end
+
+      private
+
+      def create_request_object(method, uri)
+        request_class = request_class_for(method)
+        request_class.new(uri)
+      end
+
+      def request_class_for(method)
+        case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :delete then Net::HTTP::Delete
+        else raise ArgumentError, "Unsupported HTTP method: #{method}"
+        end
+      end
+
+      def add_headers(request)
+        request['Authorization'] = @authenticator.auth_header
+        request['Accept'] = 'application/json'
+
+        # Add cookies if available
+        cookie_header = @cookie_jar.to_header
+        request['Cookie'] = cookie_header if cookie_header
+      end
+
+      def add_body(request, body)
+        request['Content-Type'] = 'application/json'
+        request.body = body.to_json
+      end
+    end
+  end
+end

data/lib/sumologic/http/response_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Sumologic
+  module Http
+    # Handles HTTP response parsing and error handling
+    class ResponseHandler
+      # Parse response and handle errors
+      def handle(response)
+        case response.code.to_i
+        when 200..299
+          parse_success(response)
+        when 401, 403
+          handle_authentication_error(response)
+        when 429
+          handle_rate_limit_error(response)
+        else
+          handle_generic_error(response)
+        end
+      end
+
+      private
+
+      def parse_success(response)
+        JSON.parse(response.body)
+      end
+
+      def handle_authentication_error(response)
+        raise AuthenticationError, "Authentication failed: #{response.body}"
+      end
+
+      def handle_rate_limit_error(response)
+        raise Error, "Rate limit exceeded: #{response.body}"
+      end
+
+      def handle_generic_error(response)
+        raise Error, "HTTP #{response.code}: #{response.body}"
+      end
+    end
+  end
+end

data/lib/sumologic/interactive/fzf_viewer/config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sumologic
+  module Interactive
+    class FzfViewer
+      module Config
+        # Display configuration
+        TIME_WIDTH = 8
+        LEVEL_WIDTH = 7
+        SOURCE_WIDTH = 25
+        MESSAGE_PREVIEW_LENGTH = 80
+        SEARCHABLE_PADDING = 5
+
+        # Searchable field names
+        SEARCHABLE_FIELDS = %w[
+          _source
+          _sourcecategory
+          _sourcename
+          _collector
+          _sourcehost
+          region
+          _group
+          _tier
+          _view
+        ].freeze
+
+        # ANSI color codes
+        COLORS = {
+          red: "\e[31m",
+          yellow: "\e[33m",
+          cyan: "\e[36m",
+          gray: "\e[90m",
+          reset: "\e[0m"
+        }.freeze
+      end
+    end
+  end
+end

data/lib/sumologic/interactive/fzf_viewer/formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sumologic
+  module Interactive
+    class FzfViewer
+      module Formatter
+        module_function
+
+        def format_time(timestamp_ms)
+          return 'N/A' unless timestamp_ms
+
+          Time.at(timestamp_ms.to_i / 1000).strftime('%H:%M:%S')
+        end
+
+        def format_level(level)
+          level_str = level.to_s.upcase.ljust(Config::LEVEL_WIDTH)
+          colorize_level(level_str)
+        end
+
+        def colorize_level(level_str)
+          case level_str.strip
+          when 'ERROR', 'FATAL', 'CRITICAL'
+            "#{Config::COLORS[:red]}#{level_str}#{Config::COLORS[:reset]}"
+          when 'WARN', 'WARNING'
+            "#{Config::COLORS[:yellow]}#{level_str}#{Config::COLORS[:reset]}"
+          when 'INFO'
+            "#{Config::COLORS[:cyan]}#{level_str}#{Config::COLORS[:reset]}"
+          when 'DEBUG', 'TRACE'
+            "#{Config::COLORS[:gray]}#{level_str}#{Config::COLORS[:reset]}"
+          else
+            level_str
+          end
+        end
+
+        def sanitize(text)
+          text.to_s.gsub(/[\n\r\t]/, ' ').squeeze(' ')
+        end
+
+        def truncate(text, length)
+          text = text.to_s
+          text.length > length ? "#{text[0...(length - 3)]}..." : text
+        end
+
+        def pad(text, width)
+          text.ljust(width)
+        end
+      end
+    end
+  end
+end

data/lib/sumologic/interactive/fzf_viewer/fzf_config.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Sumologic
+  module Interactive
+    class FzfViewer
+      module FzfConfig
+        module_function
+
+        def build_fzf_args(input_path, preview_path, header_text)
+          [
+            'fzf',
+            *search_options,
+            *display_options(preview_path, header_text),
+            *keybinding_options(input_path, preview_path)
+          ]
+        end
+
+        def search_options
+          [
+            '--ansi',
+            '--multi',
+            '--exact',       # Exact substring matching
+            '-i',            # Case-insensitive
+            '--no-hscroll'   # Prevent horizontal scrolling
+          ]
+        end
+
+        def display_options(preview_path, header_text)
+          [
+            "--header=#{header_text}",
+            "--preview=#{build_preview_command(preview_path)}",
+            '--preview-window=right:60%:wrap:follow',
+            '--height=100%'
+          ]
+        end
+
+        def keybinding_options(input_path, preview_path)
+          [
+            '--bind=enter:toggle',
+            "--bind=tab:execute(#{build_view_command(preview_path)})",
+            '--bind=ctrl-a:select-all',
+            '--bind=ctrl-d:deselect-all',
+            '--bind=ctrl-s:execute-silent(echo {+} > sumo-selected.txt)+abort',
+            '--bind=ctrl-y:execute-silent(echo {+} | pbcopy || ' \
+            'echo {+} | xclip -selection clipboard 2>/dev/null)+abort',
+            '--bind=ctrl-e:execute-silent(echo {+} > sumo-export.jsonl)+abort',
+            '--bind=ctrl-/:toggle-preview',
+            "--bind=ctrl-r:reload(cat #{input_path})",
+            '--bind=ctrl-t:toggle-search',
+            '--bind=ctrl-q:abort'
+          ]
+        end
+
+        def build_view_command(preview_path)
+          # FZF {n} is 0-indexed, sed is 1-indexed
+          'LINE=$(({n} + 1)); ' \
+            "sed -n \"$LINE\"p #{Shellwords.escape(preview_path)} | jq -C . | less -R"
+        end
+
+        def build_preview_command(preview_path)
+          escaped_path = Shellwords.escape(preview_path)
+
+          calc = "LINE=$(({n} + 1)); TOTAL=$(wc -l < #{escaped_path}); "
+          display = 'echo "Message $LINE of $TOTAL"; echo ""; '
+          extract = "sed -n \"$LINE\"p #{escaped_path}"
+
+          "#{calc}#{display}#{extract} | jq -C . || #{extract}"
+        end
+      end
+    end
+  end
+end

data/lib/sumologic/interactive/fzf_viewer/header_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sumologic
+  module Interactive
+    class FzfViewer
+      module HeaderBuilder
+        module_function
+
+        def build_header_text(results, messages)
+          [
+            build_column_headers,
+            build_info_line(results, messages),
+            build_search_tips,
+            build_keybindings_help
+          ].join("\n")
+        end
+
+        def build_column_headers
+          "#{Formatter.pad('TIME', Config::TIME_WIDTH)} " \
+            "#{Formatter.pad('LEVEL', Config::LEVEL_WIDTH)} " \
+            "#{Formatter.pad('SOURCE', Config::SOURCE_WIDTH)} MESSAGE"
+        end
+
+        def build_info_line(results, messages)
+          query = results['query'] || 'N/A'
+          count = messages.size
+          sources = messages.map { |m| m['map']['_source'] }.compact.uniq.size
+
+          "#{count} msgs | #{sources} sources | Query: #{Formatter.truncate(query, 40)}"
+        end
+
+        def build_search_tips
+          '💡 Simple text search (case-insensitive) - searches all JSON fields and log content'
+        end
+
+        def build_keybindings_help
+          'Enter=select Tab=view Ctrl-T=toggle-search Ctrl-S=save Ctrl-Y=copy Ctrl-E=export Ctrl-Q=quit'
+        end
+      end
+    end
+  end
+end

data/lib/sumologic/interactive/fzf_viewer/searchable_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sumologic
+  module Interactive
+    class FzfViewer
+      module SearchableBuilder
+        module_function
+
+        def build_searchable_content(map)
+          parts = []
+
+          add_primary_content(parts, map)
+          add_standard_fields(parts, map)
+          add_custom_fields(parts, map)
+
+          parts.compact.join(' ')
+        end
+
+        def add_primary_content(parts, map)
+          parts << Formatter.sanitize(map['_raw'] || map['message'] || '')
+        end
+
+        def add_standard_fields(parts, map)
+          Config::SEARCHABLE_FIELDS.each do |field|
+            parts << map[field] if map[field]
+          end
+        end
+
+        def add_custom_fields(parts, map)
+          map.each do |key, value|
+            next if key.start_with?('_')
+            next if value.nil? || value.to_s.empty?
+
+            parts << "#{key}:#{value}"
+          end
+        end
+      end
+    end
+  end
+end