cloudwatch_query 0.1.0

data/lib/cloudwatch_query/parsers/rails/sub_parsers.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module CloudwatchQuery
+  module Parsers
+    module Rails
+      # Base module for Rails sub-parsers
+      module SubParser
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def matches?(_message)
+            raise NotImplementedError
+          end
+
+          def parse(_message, _base_data)
+            raise NotImplementedError
+          end
+        end
+      end
+
+      # Parses: "Started GET "/path" for 1.2.3.4 at 2026-02-04 18:37:21 +0000"
+      class RequestSubParser
+        include SubParser
+
+        REQUEST_REGEX = /Started\s+(?<http_method>GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+"(?<path>[^"]+)"\s+for\s+(?<ip_address>[\d.]+)\s+at\s+(?<timestamp>.+)$/
+
+        def self.matches?(message)
+          message.include?("Started ") &&
+            (message.include?(" GET ") || message.include?(" POST ") ||
+             message.include?(" PUT ") || message.include?(" PATCH ") ||
+             message.include?(" DELETE "))
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(REQUEST_REGEX)
+          return {} unless match
+
+          {
+            line_type: :request,
+            http_method: match[:http_method],
+            path: match[:path],
+            ip_address: match[:ip_address],
+            request_timestamp: match[:timestamp]
+          }
+        end
+      end
+
+      # Parses: "Parameters: {...}"
+      class ParametersSubParser
+        include SubParser
+
+        PARAMS_REGEX = /Parameters:\s+(?<params>\{.+\})$/
+
+        def self.matches?(message)
+          message.include?("Parameters: {")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(PARAMS_REGEX)
+          return {} unless match
+
+          {
+            line_type: :parameters,
+            params: safe_parse_params(match[:params])
+          }
+        end
+
+        def self.safe_parse_params(params_string)
+          JSON.parse(
+            params_string
+              .gsub(/=>/, ":")
+              .gsub(/:(\w+)/, '"\1"')
+              .gsub(/nil/, "null")
+          )
+        rescue JSON::ParserError, StandardError
+          { raw: params_string }
+        end
+      end
+
+      # Parses: "Redirected to https://..."
+      class RedirectSubParser
+        include SubParser
+
+        REDIRECT_REGEX = /Redirected to\s+(?<redirect_url>.+)$/
+
+        def self.matches?(message)
+          message.include?("Redirected to ")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(REDIRECT_REGEX)
+          return {} unless match
+
+          {
+            line_type: :redirect,
+            redirect_url: match[:redirect_url].strip
+          }
+        end
+      end
+
+      # Parses: "[ActiveJob] Enqueued JobClass (Job ID: uuid) to Sidekiq(queue)"
+      class ActiveJobSubParser
+        include SubParser
+
+        ACTIVE_JOB_REGEX = /\[ActiveJob\]\s+Enqueued\s+(?<job_class>[\w:]+)\s+\(Job ID:\s+(?<job_id>[^)]+)\)\s+to\s+\w+\((?<queue>\w+)\)(?:\s+with arguments:\s+(?<arguments>.+))?$/
+
+        def self.matches?(message)
+          message.include?("[ActiveJob] Enqueued")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(ACTIVE_JOB_REGEX)
+          return {} unless match
+
+          {
+            line_type: :active_job,
+            job_class: match[:job_class],
+            job_id: match[:job_id],
+            queue: match[:queue],
+            arguments: match[:arguments]&.strip
+          }
+        end
+      end
+
+      # Parses: "Processing by Controller#action as FORMAT"
+      class ProcessingSubParser
+        include SubParser
+
+        PROCESSING_REGEX = /Processing by\s+(?<controller>\w+)#(?<action>\w+)\s+as\s+(?<format>\w+)/
+
+        def self.matches?(message)
+          message.include?("Processing by ")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(PROCESSING_REGEX)
+          return {} unless match
+
+          {
+            line_type: :processing,
+            controller: match[:controller],
+            action: match[:action],
+            format: match[:format]
+          }
+        end
+      end
+
+      # Parses: "Completed 200 OK in 123ms"
+      class CompletedSubParser
+        include SubParser
+
+        COMPLETED_REGEX = /Completed\s+(?<status>\d+)\s+\w+\s+in\s+(?<duration>[\d.]+)(?<unit>ms|s)/
+
+        def self.matches?(message)
+          message.include?("Completed ")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(COMPLETED_REGEX)
+          return {} unless match
+
+          duration_ms = match[:unit] == "s" ? match[:duration].to_f * 1000 : match[:duration].to_f
+
+          {
+            line_type: :completed,
+            status_code: match[:status].to_i,
+            duration_ms: duration_ms
+          }
+        end
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers/rails_parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "rails/sub_parsers"
+require_relative "rails/rails_log"
+
+module CloudwatchQuery
+  module Parsers
+    class RailsParser < Base
+      # Built-in sub-parsers mapped to symbols
+      BUILT_IN_SUB_PARSERS = {
+        request: Rails::RequestSubParser,
+        parameters: Rails::ParametersSubParser,
+        redirect: Rails::RedirectSubParser,
+        active_job: Rails::ActiveJobSubParser,
+        processing: Rails::ProcessingSubParser,
+        completed: Rails::CompletedSubParser
+      }.freeze
+
+      # Matches request UUID pattern: [abc-123-def-456]
+      REQUEST_ID_REGEX = /\[(?<request_id>[a-f0-9-]{36})\]/
+
+      # Matches syslog prefix: "Feb  4 22:37:47 ip-10-15-1-216 cryo[1030829]:"
+      SYSLOG_PREFIX_REGEX = /^(?<syslog_timestamp>\w+\s+\d+\s+[\d:]+)\s+(?<server>[\w.-]+)\s+\w+\[(?<process_id>\d+)\]:\s*/
+
+      attr_reader :sub_parsers
+
+      # Initialize with specific sub-parsers or use all defaults
+      #
+      # @example Use all defaults
+      #   RailsParser.new
+      #
+      # @example Use only specific built-in sub-parsers
+      #   RailsParser.new(:request, :parameters)
+      #
+      # @example Mix built-in and custom sub-parsers
+      #   RailsParser.new(:request, :parameters, MyCustomSubParser)
+      #
+      # @example All defaults plus custom
+      #   RailsParser.new(:all, MyCustomSubParser)
+      #
+      def initialize(*args)
+        @sub_parsers = resolve_sub_parsers(args)
+      end
+
+      def matches?(message)
+        # Must have a Rails request UUID pattern
+        message.match?(REQUEST_ID_REGEX)
+      end
+
+      def parse(message)
+        return nil unless matches?(message)
+
+        base_data = extract_base_data(message)
+        clean_message = strip_syslog_prefix(message)
+
+        # Try each sub-parser until one matches
+        sub_parser_data = {}
+        @sub_parsers.each do |parser|
+          if parser.matches?(clean_message)
+            sub_parser_data = parser.parse(clean_message, base_data)
+            break if sub_parser_data[:line_type]
+          end
+        end
+
+        # If no sub-parser matched, mark as unknown
+        sub_parser_data[:line_type] ||= :unknown
+        sub_parser_data[:raw_message] = message if sub_parser_data[:line_type] == :unknown
+
+        Rails::RailsLog.new(base_data.merge(sub_parser_data))
+      end
+
+      # Class method for simple usage (uses all defaults)
+      class << self
+        def matches?(message)
+          new.matches?(message)
+        end
+
+        def parse(message)
+          new.parse(message)
+        end
+
+        def parser_name
+          "rails"
+        end
+
+        # List available built-in sub-parser names
+        def available_sub_parsers
+          BUILT_IN_SUB_PARSERS.keys
+        end
+      end
+
+      private
+
+      def resolve_sub_parsers(args)
+        return BUILT_IN_SUB_PARSERS.values if args.empty?
+
+        parsers = []
+        args.each do |arg|
+          case arg
+          when :all
+            parsers.concat(BUILT_IN_SUB_PARSERS.values)
+          when Symbol
+            parser = BUILT_IN_SUB_PARSERS[arg]
+            raise ArgumentError, "Unknown sub-parser: #{arg}. Available: #{BUILT_IN_SUB_PARSERS.keys.join(', ')}" unless parser
+
+            parsers << parser
+          else
+            # Assume it's a custom sub-parser class/object
+            validate_sub_parser!(arg)
+            parsers << arg
+          end
+        end
+        parsers.uniq
+      end
+
+      def validate_sub_parser!(parser)
+        unless parser.respond_to?(:matches?) && parser.respond_to?(:parse)
+          raise ArgumentError, "Sub-parser must respond to .matches?(message) and .parse(message, base_data)"
+        end
+      end
+
+      def extract_base_data(message)
+        data = {}
+
+        # Extract request ID
+        if (match = message.match(REQUEST_ID_REGEX))
+          data[:request_id] = match[:request_id]
+        end
+
+        # Extract syslog prefix data
+        if (match = message.match(SYSLOG_PREFIX_REGEX))
+          data[:server] = match[:server]
+          data[:process_id] = match[:process_id]
+        end
+
+        data
+      end
+
+      def strip_syslog_prefix(message)
+        message.sub(SYSLOG_PREFIX_REGEX, "")
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers/registry.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module CloudwatchQuery
+  module Parsers
+    class Registry
+      def initialize
+        @parsers = []
+      end
+
+      # Register one or more parsers (appends to end, lower priority)
+      def register(*parsers)
+        parsers.flatten.each do |parser|
+          validate_parser!(parser)
+          @parsers << parser unless @parsers.include?(parser)
+        end
+        self
+      end
+
+      # Add parser(s) at the beginning (highest priority)
+      def prepend(*parsers)
+        parsers.flatten.reverse.each do |parser|
+          validate_parser!(parser)
+          @parsers.delete(parser)
+          @parsers.unshift(parser)
+        end
+        self
+      end
+
+      # Insert parser at specific index
+      def insert(index, parser)
+        validate_parser!(parser)
+        @parsers.delete(parser)
+        @parsers.insert(index, parser)
+        self
+      end
+
+      # Remove a parser
+      def unregister(parser)
+        @parsers.delete(parser)
+        self
+      end
+
+      # Clear all parsers
+      def clear
+        @parsers.clear
+        self
+      end
+
+      # List all registered parsers
+      def list
+        @parsers.dup
+      end
+
+      # Parse a message using the first matching parser
+      # Returns [parsed_object, parser_name] or [nil, nil] if no match
+      def parse(message)
+        return [nil, nil] if message.nil? || message.empty?
+
+        @parsers.each do |parser|
+          if parser.matches?(message)
+            begin
+              parsed = parser.parse(message)
+              return [parsed, get_parser_name(parser)] if parsed
+            rescue StandardError
+              # Parser failed, try next one
+              next
+            end
+          end
+        end
+
+        [nil, nil]
+      end
+
+      private
+
+      def get_parser_name(parser)
+        if parser.respond_to?(:parser_name)
+          parser.parser_name
+        elsif parser.class.respond_to?(:parser_name)
+          parser.class.parser_name
+        else
+          parser.class.name.split("::").last.sub(/Parser$/, "").downcase
+        end
+      end
+
+      def validate_parser!(parser)
+        unless parser.respond_to?(:matches?) && parser.respond_to?(:parse)
+          raise ArgumentError, "Parser must respond to .matches?(message) and .parse(message)"
+        end
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers/sidekiq/sidekiq_log.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module CloudwatchQuery
+  module Parsers
+    module Sidekiq
+      class SidekiqLog
+        attr_reader :timestamp, :pid, :tid, :job_class, :jid,
+                    :line_type, :status, :elapsed,
+                    :raw_message
+
+        def initialize(attributes = {})
+          attributes.each do |key, value|
+            instance_variable_set("@#{key}", value) if respond_to?(key)
+          end
+          @line_type ||= :unknown
+        end
+
+        def type
+          :sidekiq
+        end
+
+        def start?
+          line_type == :start
+        end
+
+        def done?
+          line_type == :done
+        end
+
+        def fail?
+          line_type == :fail
+        end
+
+        # Alias for elapsed
+        def duration
+          elapsed
+        end
+
+        def to_h
+          instance_variables.each_with_object({}) do |var, hash|
+            key = var.to_s.delete("@").to_sym
+            value = instance_variable_get(var)
+            hash[key] = value unless value.nil?
+          end
+        end
+
+        def [](key)
+          instance_variable_get("@#{key}")
+        end
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers/sidekiq/sub_parsers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module CloudwatchQuery
+  module Parsers
+    module Sidekiq
+      # Base module for Sidekiq sub-parsers
+      module SubParser
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def matches?(_message)
+            raise NotImplementedError
+          end
+
+          def parse(_message, _base_data)
+            raise NotImplementedError
+          end
+        end
+      end
+
+      # Parses job start: "INFO: start"
+      class StartSubParser
+        include SubParser
+
+        def self.matches?(message)
+          message.end_with?("INFO: start")
+        end
+
+        def self.parse(_message, _base_data)
+          {
+            line_type: :start,
+            status: "start"
+          }
+        end
+      end
+
+      # Parses job done with elapsed: "elapsed=0.152 INFO: done"
+      class DoneSubParser
+        include SubParser
+
+        ELAPSED_REGEX = /elapsed=(?<elapsed>[\d.]+)\s+INFO:\s+done$/
+
+        def self.matches?(message)
+          message.include?("INFO: done")
+        end
+
+        def self.parse(message, _base_data)
+          match = message.match(ELAPSED_REGEX)
+          elapsed = match ? match[:elapsed].to_f : nil
+
+          {
+            line_type: :done,
+            status: "done",
+            elapsed: elapsed
+          }
+        end
+      end
+
+      # Parses job failure: "INFO: fail" or error messages
+      class FailSubParser
+        include SubParser
+
+        def self.matches?(message)
+          message.include?("INFO: fail") || message.include?("ERROR:")
+        end
+
+        def self.parse(message, _base_data)
+          {
+            line_type: :fail,
+            status: "fail"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers/sidekiq_parser.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "sidekiq/sub_parsers"
+require_relative "sidekiq/sidekiq_log"
+
+module CloudwatchQuery
+  module Parsers
+    class SidekiqParser < Base
+      # Built-in sub-parsers mapped to symbols
+      BUILT_IN_SUB_PARSERS = {
+        start: Sidekiq::StartSubParser,
+        done: Sidekiq::DoneSubParser,
+        fail: Sidekiq::FailSubParser
+      }.freeze
+
+      # Matches Sidekiq log format: "2026-02-04T20:46:15.201Z pid=123 tid=abc class=Job jid=xyz"
+      SIDEKIQ_PATTERN = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s+pid=\d+\s+tid=\w+\s+class=/
+      BASE_REGEX = /^(?<timestamp>\d{4}-\d{2}-\d{2}T[\d:.]+Z)\s+pid=(?<pid>\d+)\s+tid=(?<tid>\w+)\s+class=(?<job_class>[\w:]+)\s+jid=(?<jid>\w+)/
+
+      attr_reader :sub_parsers
+
+      # Initialize with specific sub-parsers or use all defaults
+      #
+      # @example Use all defaults
+      #   SidekiqParser.new
+      #
+      # @example Use only specific built-in sub-parsers
+      #   SidekiqParser.new(:start, :done)
+      #
+      # @example Mix built-in and custom sub-parsers
+      #   SidekiqParser.new(:start, :done, MyCustomSubParser)
+      #
+      # @example All defaults plus custom
+      #   SidekiqParser.new(:all, MyCustomSubParser)
+      #
+      def initialize(*args)
+        @sub_parsers = resolve_sub_parsers(args)
+      end
+
+      def matches?(message)
+        message.match?(SIDEKIQ_PATTERN)
+      end
+
+      def parse(message)
+        return nil unless matches?(message)
+
+        base_data = extract_base_data(message)
+        return nil if base_data.empty?
+
+        # Try each sub-parser until one matches
+        sub_parser_data = {}
+        @sub_parsers.each do |parser|
+          if parser.matches?(message)
+            sub_parser_data = parser.parse(message, base_data)
+            break if sub_parser_data[:line_type]
+          end
+        end
+
+        # If no sub-parser matched, mark as unknown
+        sub_parser_data[:line_type] ||= :unknown
+        sub_parser_data[:raw_message] = message if sub_parser_data[:line_type] == :unknown
+
+        Sidekiq::SidekiqLog.new(base_data.merge(sub_parser_data))
+      end
+
+      # Class method for simple usage (uses all defaults)
+      class << self
+        def matches?(message)
+          new.matches?(message)
+        end
+
+        def parse(message)
+          new.parse(message)
+        end
+
+        def parser_name
+          "sidekiq"
+        end
+
+        # List available built-in sub-parser names
+        def available_sub_parsers
+          BUILT_IN_SUB_PARSERS.keys
+        end
+      end
+
+      private
+
+      def resolve_sub_parsers(args)
+        return BUILT_IN_SUB_PARSERS.values if args.empty?
+
+        parsers = []
+        args.each do |arg|
+          case arg
+          when :all
+            parsers.concat(BUILT_IN_SUB_PARSERS.values)
+          when Symbol
+            parser = BUILT_IN_SUB_PARSERS[arg]
+            raise ArgumentError, "Unknown sub-parser: #{arg}. Available: #{BUILT_IN_SUB_PARSERS.keys.join(', ')}" unless parser
+
+            parsers << parser
+          else
+            # Assume it's a custom sub-parser class/object
+            validate_sub_parser!(arg)
+            parsers << arg
+          end
+        end
+        parsers.uniq
+      end
+
+      def validate_sub_parser!(parser)
+        unless parser.respond_to?(:matches?) && parser.respond_to?(:parse)
+          raise ArgumentError, "Sub-parser must respond to .matches?(message) and .parse(message, base_data)"
+        end
+      end
+
+      def extract_base_data(message)
+        match = message.match(BASE_REGEX)
+        return {} unless match
+
+        {
+          timestamp: match[:timestamp],
+          pid: match[:pid],
+          tid: match[:tid],
+          job_class: match[:job_class],
+          jid: match[:jid]
+        }
+      end
+    end
+  end
+end

data/lib/cloudwatch_query/parsers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "parsers/base"
+require_relative "parsers/registry"
+require_relative "parsers/rails_parser"
+require_relative "parsers/sidekiq_parser"
+
+module CloudwatchQuery
+  module Parsers
+    class << self
+      def default_parsers
+        [
+          RailsParser.new,
+          SidekiqParser.new
+        ]
+      end
+    end
+  end
+end