makit 0.0.99 → 0.0.112

data/lib/makit/logging/format_registry.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    # Registry for managing available log formatters
+    #
+    # Provides a centralized way to register, retrieve, and manage formatters
+    # by name. This allows for easy extension and configuration of formatters.
+    #
+    # @example Registering a custom formatter
+    #   FormatRegistry.register(:audit, AuditFormatter)
+    #   formatter = FormatRegistry.get(:audit).new
+    #
+    # @example Using built-in formatters
+    #   formatter = FormatRegistry.get(:json).new
+    #   formatter = FormatRegistry.get(:text).new(timestamp_format: "%H:%M:%S")
+    class FormatRegistry
+      @formatters = {}
+
+      class << self
+        # @return [Hash] registered formatters
+        attr_reader :formatters
+
+        # Register a formatter class with a name
+        #
+        # @param name [Symbol, String] the name to register the formatter under
+        # @param formatter_class [Class] the formatter class to register
+        # @return [void]
+        def register(name, formatter_class)
+          @formatters[name.to_sym] = formatter_class
+        end
+
+        # Get a formatter class by name
+        #
+        # @param name [Symbol, String] the name of the formatter
+        # @return [Class] the formatter class
+        # @raise [ArgumentError] if formatter is not found
+        def get(name)
+          @formatters[name.to_sym] || raise(ArgumentError, "Unknown formatter: #{name}")
+        end
+
+        # Get all available formatter names
+        #
+        # @return [Array<Symbol>] list of registered formatter names
+        def available_formats
+          @formatters.keys
+        end
+
+        # Check if a formatter is registered
+        #
+        # @param name [Symbol, String] the name to check
+        # @return [Boolean] true if formatter is registered
+        def registered?(name)
+          @formatters.key?(name.to_sym)
+        end
+
+        # Clear all registered formatters
+        #
+        # @return [void]
+        def clear
+          @formatters.clear
+        end
+
+        # Register built-in formatters
+        #
+        # @return [void]
+        def register_built_ins
+          require_relative "formatters/json_formatter"
+          require_relative "formatters/text_formatter"
+          require_relative "formatters/plain_text_formatter"
+          require_relative "formatters/console_formatter"
+
+          register(:json, Formatters::JsonFormatter)
+          register(:text, Formatters::TextFormatter)
+          register(:plain, Formatters::PlainTextFormatter)
+          register(:console, Formatters::ConsoleFormatter)
+        end
+      end
+
+      # Initialize registry with built-in formatters
+      register_built_ins
+    end
+  end
+end

data/lib/makit/logging/formatters/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    module Formatters
+      # Base class for all logging formatters
+      #
+      # Formatters handle the conversion of log requests into formatted strings
+      # that can be written to various outputs (console, files, etc.).
+      # This separates formatting concerns from output routing concerns.
+      #
+      # @example Creating a custom formatter
+      #   class CustomFormatter < Base
+      #     def format(log_request)
+      #       "#{log_request.level.upcase}: #{log_request.message}"
+      #     end
+      #   end
+      class Base
+        # Format a log request into a string
+        #
+        # @param log_request [LogRequest] the log request to format
+        # @return [String] the formatted log entry
+        def format(log_request)
+          raise NotImplementedError, "Subclasses must implement #format"
+        end
+
+        # Get formatter configuration
+        #
+        # @return [Hash] formatter configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            type: self.class.name,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/formatters/console_formatter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+begin
+  require "colorize"
+rescue LoadError
+  # colorize gem not available, define a no-op colorize method
+  class String
+    def colorize(*args)
+      self
+    end
+  end
+end
+require_relative "base"
+
+module Makit
+  module Logging
+    module Formatters
+      # Console formatter for colored log output
+      #
+      # Formats log requests for console display with colors, symbols, and optional
+      # timestamps/levels. This is specifically designed for human-readable console output.
+      #
+      # @example
+      #   formatter = ConsoleFormatter.new
+      #   formatted = formatter.format(log_request)
+      #   # => "→ Processing started" (with appropriate color)
+      class ConsoleFormatter < Base
+        # @return [Boolean] whether to show timestamps
+        attr_reader :show_timestamp
+        # @return [Boolean] whether to show log levels
+        attr_reader :show_level
+
+        # Initialize console formatter
+        #
+        # @param show_timestamp [Boolean] whether to show timestamps (default: false)
+        # @param show_level [Boolean] whether to show log levels (default: false)
+        def initialize(show_timestamp: false, show_level: false)
+          @show_timestamp = show_timestamp
+          @show_level = show_level
+        end
+
+        # Format log request for console display
+        #
+        # @param log_request [LogRequest] the log request to format
+        # @return [String] console formatted log entry with colors
+        def format(log_request)
+          parts = []
+
+          # Add timestamp if enabled
+          if @show_timestamp
+            timestamp = log_request.timestamp.strftime("%H:%M:%S")
+            parts << "[#{timestamp}]".colorize(:light_black)
+          end
+
+          # Add log level if enabled
+          if @show_level
+            level_str = log_request.level.to_s.upcase
+            level_color = get_level_color(log_request.level)
+            parts << level_str.colorize(level_color)
+          end
+
+          # Add symbol and message
+          symbol = get_level_symbol(log_request.level)
+          symbol_color = get_level_color(log_request.level)
+          message = log_request.message
+
+          # Special handling for task messages - no symbol, no context, just the message
+          if log_request.context[:task_message]
+            parts << message
+          else
+            # Add context if present (only for non-task messages)
+            if !log_request.context.empty?
+              context_str = log_request.context.map { |k, v| "#{k}=#{v}" }.join(" ")
+              message += " #{context_str}".colorize(:light_black)
+            end
+            parts << "#{symbol} #{message}".colorize(symbol_color)
+          end
+
+          parts.join(" ")
+        end
+
+        # Get formatter configuration
+        #
+        # @return [Hash] formatter configuration
+        def config
+          super.merge(
+            show_timestamp: @show_timestamp,
+            show_level: @show_level,
+          )
+        end
+
+        private
+
+        # Get the color for a log level
+        #
+        # @param level [Symbol] the log level
+        # @return [Symbol] the color for the level
+        def get_level_color(level)
+          case level
+          when :debug
+            :grey
+          when :info
+            :grey
+          when :warn
+            :light_yellow
+          when :error, :fatal
+            :light_red
+          when :success
+            :green
+          else
+            :white
+          end
+        end
+
+        # Get the symbol for a log level
+        #
+        # @param level [Symbol] the log level
+        # @return [String] the symbol for the level
+        def get_level_symbol(level)
+          case level
+          when :debug
+            "•"
+          when :info
+            " " #"→"
+          when :warn
+            "!" #"⚠"
+          when :error
+            "✗"
+          when :fatal
+            "💀"
+          when :success
+            "✓"
+          else
+            "•"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/formatters/json_formatter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base"
+
+module Makit
+  module Logging
+    module Formatters
+      # JSON formatter for structured logging
+      #
+      # Formats log requests as JSON objects with timestamp, level, message, and context.
+      # This is ideal for log aggregation systems and structured data analysis.
+      #
+      # @example
+      #   formatter = JsonFormatter.new
+      #   formatted = formatter.format(log_request)
+      #   # => '{"timestamp":"2024-01-15T10:30:45Z","level":"INFO","message":"User logged in","context":{"user_id":123}}'
+      class JsonFormatter < Base
+        # @return [Hash] additional options for JSON formatting
+        attr_reader :options
+
+        # Initialize JSON formatter
+        #
+        # @param options [Hash] JSON generation options
+        def initialize(options: {})
+          @options = {
+            indent: nil,
+            space: nil,
+            space_before: nil,
+            object_nl: nil,
+            array_nl: nil,
+            allow_nan: false,
+            max_nesting: 100,
+          }.merge(options)
+        end
+
+        # Format log request as JSON
+        #
+        # @param log_request [LogRequest] the log request to format
+        # @return [String] JSON formatted log entry
+        def format(log_request)
+          log_data = {
+            timestamp: log_request.timestamp.iso8601,
+            level: log_request.level.to_s.upcase,
+            message: log_request.message,
+          }
+
+          # Add context if present
+          log_data[:context] = log_request.context unless log_request.context.empty?
+
+          JSON.generate(log_data, @options)
+        end
+
+        # Get formatter configuration
+        #
+        # @return [Hash] formatter configuration including JSON options
+        def config
+          super.merge(
+            json_options: @options,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/formatters/plain_text_formatter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Makit
+  module Logging
+    module Formatters
+      # Plain text formatter with just the message
+      #
+      # Formats log requests as plain text containing only the message content.
+      # This is useful for simple log files where only the message matters.
+      #
+      # @example
+      #   formatter = PlainTextFormatter.new
+      #   formatted = formatter.format(log_request)
+      #   # => 'User logged in'
+      class PlainTextFormatter < Base
+        # @return [Boolean] whether to include context in output
+        attr_reader :include_context
+
+        # Initialize plain text formatter
+        #
+        # @param include_context [Boolean] whether to include context in output
+        def initialize(include_context: false)
+          @include_context = include_context
+        end
+
+        # Format log request as plain text
+        #
+        # @param log_request [LogRequest] the log request to format
+        # @return [String] plain text formatted log entry
+        def format(log_request)
+          message = log_request.message
+
+          # Add context if enabled and present
+          if @include_context && !log_request.context.empty?
+            # Create a more readable context representation
+            context_parts = log_request.context.map do |k, v|
+              # Format values nicely based on their type
+              formatted_value = case v
+                when String
+                  v.include?(" ") ? "\"#{v}\"" : v
+                when Hash, Array
+                  v.inspect
+                when Time
+                  v.strftime("%Y-%m-%d %H:%M:%S")
+                else
+                  v.to_s
+                end
+              "#{k}: #{formatted_value}"
+            end
+
+            context_str = context_parts.join(", ")
+            message += " (#{context_str})"
+          end
+
+          message
+        end
+
+        # Get formatter configuration
+        #
+        # @return [Hash] formatter configuration
+        def config
+          super.merge(
+            include_context: @include_context,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/formatters/text_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Makit
+  module Logging
+    module Formatters
+      # Text formatter with timestamp and log level
+      #
+      # Formats log requests as human-readable text with timestamp, log level,
+      # and message. This is the most common format for traditional log files.
+      #
+      # @example
+      #   formatter = TextFormatter.new
+      #   formatted = formatter.format(log_request)
+      #   # => '[2024-01-15 10:30:45] INFO User logged in'
+      class TextFormatter < Base
+        # @return [String] timestamp format string
+        attr_reader :timestamp_format
+        # @return [Boolean] whether to include context in output
+        attr_reader :include_context
+
+        # Initialize text formatter
+        #
+        # @param timestamp_format [String] strftime format for timestamps
+        # @param include_context [Boolean] whether to include context in output
+        def initialize(timestamp_format: "%Y-%m-%d %H:%M:%S", include_context: false)
+          @timestamp_format = timestamp_format
+          @include_context = include_context
+        end
+
+        # Format log request as text
+        #
+        # @param log_request [LogRequest] the log request to format
+        # @return [String] text formatted log entry
+        def format(log_request)
+          timestamp = log_request.timestamp.strftime(@timestamp_format)
+          level = log_request.level.to_s.upcase
+          message = log_request.message
+
+          formatted = "[#{timestamp}] #{level} #{message}"
+
+          # Add context if enabled and present
+          if @include_context && !log_request.context.empty?
+            context_str = log_request.context.map { |k, v| "#{k}=#{v}" }.join(" ")
+            formatted += " #{context_str}"
+          end
+
+          formatted
+        end
+
+        # Get formatter configuration
+        #
+        # @return [Hash] formatter configuration
+        def config
+          super.merge(
+            timestamp_format: @timestamp_format,
+            include_context: @include_context,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/log_request.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    # Represents a log request that flows through the logging middleware chain
+    #
+    # This class encapsulates all the information needed for a log entry,
+    # including the log level, message, context, and metadata. It provides
+    # a clean interface for middleware to process and modify log information.
+    #
+    # @example Basic usage
+    #   request = LogRequest.new(:info, "Processing started")
+    #   request.add_metadata(process_id: 12345)
+    #   puts request.to_h
+    #
+    # @example With context
+    #   request = LogRequest.new(:error, "Build failed", {
+    #     repository: "user/repo",
+    #     commit: "abc123"
+    #   })
+    class LogRequest
+      # @return [Symbol] the log level (:debug, :info, :warn, :error, :fatal, :success)
+      attr_reader :level
+
+      # @return [String] the log message
+      attr_reader :message
+
+      # @return [Hash] additional context information
+      attr_reader :context
+
+      # @return [Hash] metadata about the log entry
+      attr_reader :metadata
+
+      # @return [Time] when the log request was created
+      attr_reader :timestamp
+
+      # Initialize a new log request
+      #
+      # @param level [Symbol] the log level
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      def initialize(level, message, context = {})
+        @level = level
+        @message = message
+        @context = context.dup
+        @metadata = {}
+        @timestamp = Time.now
+      end
+
+      # Add metadata to the log request
+      #
+      # @param data [Hash] metadata to add
+      # @return [void]
+      def add_metadata(data)
+        @metadata.merge!(data)
+      end
+
+      # Convert the log request to a hash representation
+      #
+      # @return [Hash] hash representation of the log request
+      def to_h
+        {
+          level: @level,
+          message: @message,
+          context: @context,
+          metadata: @metadata,
+          timestamp: @timestamp.iso8601,
+        }
+      end
+
+      # Convert the log request to a JSON string
+      #
+      # @return [String] JSON representation of the log request
+      def to_json
+        require "json"
+        JSON.generate(to_h)
+      end
+
+      # Get a formatted string representation
+      #
+      # @return [String] formatted string representation
+      def to_s
+        "[#{@timestamp.strftime("%Y-%m-%d %H:%M:%S")}] #{@level.to_s.upcase}: #{@message}"
+      end
+
+      # Check if this is an error level log
+      #
+      # @return [Boolean] true if error level
+      def error?
+        @level == :error || @level == :fatal
+      end
+
+      # Check if this is a success level log
+      #
+      # @return [Boolean] true if success level
+      def success?
+        @level == :success
+      end
+
+      # Check if this is an info level log
+      #
+      # @return [Boolean] true if info level
+      def info?
+        @level == :info
+      end
+
+      # Check if this is a warning level log
+      #
+      # @return [Boolean] true if warn level
+      def warn?
+        @level == :warn
+      end
+    end
+  end
+end