makit 0.0.99 → 0.0.112

data/lib/makit/logging/logger.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "log_request"
+require_relative "sinks/base"
+require_relative "sinks/console"
+require_relative "sinks/file_sink"
+require_relative "sinks/structured"
+
+module Makit
+  module Logging
+    # Main logger class that orchestrates logging through sinks
+    #
+    # This class provides a clean interface for logging with support for
+    # sink-based output processing. It follows the same pattern as the
+    # Commands::Runner but for logging operations.
+    #
+    # @example Basic usage
+    #   logger = Logger.new
+    #   logger.info("Processing started")
+    #
+    # @example With custom sinks
+    #   logger = Logger.new(
+    #     sinks: [
+    #       Sinks::Console.new,
+    #       Sinks::File.new(log_file: "custom.log")
+    #     ]
+    #   )
+    #
+    # @example Using convenience methods
+    #   logger.success("Build completed")
+    #   logger.error("Build failed", { repository: "user/repo" })
+    class Logger
+      # @return [Array<Sinks::Base>] list of sinks to process log requests
+      attr_reader :sinks
+      # @return [Symbol] minimum log level for filtering
+      attr_reader :level
+
+      # Initialize the logger with sinks and log level
+      #
+      # @param sinks [Array<Sinks::Base>] list of sinks to use
+      # @param level [Symbol] minimum log level (:debug, :info, :warn, :error, :fatal, :success)
+      def initialize(sinks: [], level: :info)
+        @sinks = sinks
+        @level = level
+        @logged_tasks = Set.new
+      end
+
+      # Log a message with the specified level
+      #
+      # @param level [Symbol] the log level (:debug, :info, :warn, :error, :fatal, :success)
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def log(level, message, context = {})
+        return unless should_log?(level)
+
+        log_request = LogRequest.new(level, message, context)
+        execute_sinks(log_request)
+      end
+
+      # Log an info message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def info(message, context = {})
+        log(:info, message, context)
+      end
+
+      # Log a success message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def success(message, context = {})
+        log(:success, message, context)
+      end
+
+      # Log an error message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def error(message, context = {})
+        log(:error, message, context)
+      end
+
+      # Log a warning message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def warn(message, context = {})
+        log(:warn, message, context)
+      end
+
+      # Log a debug message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def debug(message, context = {})
+        log(:debug, message, context)
+      end
+
+      # Log a fatal message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def fatal(message, context = {})
+        log(:fatal, message, context)
+      end
+
+      def task_start(message, context = {})
+        return if @logged_tasks.include?(message)
+        @logged_tasks.add(message)
+        # Format task name with colon prefix and bold white styling
+        formatted_message = ": #{message}".colorize(:white).bold
+        # Add special context to identify task messages
+        task_context = context.merge(task_message: true)
+        log(:info, formatted_message, task_context)
+      end
+
+      # Get logger configuration
+      #
+      # @return [Hash] logger configuration
+      def config
+        {
+          level: @level,
+          sinks_count: @sinks.length,
+          sinks: @sinks.map(&:config),
+        }
+      end
+
+      private
+
+      # Check if a log level should be processed
+      #
+      # @param level [Symbol] the log level to check
+      # @return [Boolean] true if the level should be logged
+      def should_log?(level)
+        levels = [:debug, :info, :warn, :error, :fatal, :success]
+        levels.index(level) >= levels.index(@level)
+      end
+
+      # Execute the sink chain for a log request
+      #
+      # @param log_request [LogRequest] the log request to process
+      # @return [void]
+      def execute_sinks(log_request)
+        # Filter applicable sinks
+        applicable_sinks = @sinks.select { |s| s.applicable?(log_request) }
+
+        # Execute sink chain
+        applicable_sinks.reduce(log_request) do |request, sink|
+          sink.call(request)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    module Sinks
+      # Base class for all logging sinks
+      #
+      # Sinks provide a way to output log requests to various destinations like
+      # console, files, or external services. This follows the same pattern as
+      # the commands middleware but focuses on output rather than transformation.
+      #
+      # @example Creating a custom logging sink
+      #   class CustomSink < Base
+      #     def call(log_request, &block)
+      #       # Output the log request
+      #       output_log(log_request)
+      #
+      #       # Continue to next sink
+      #       block.call(log_request) if block_given?
+      #     end
+      #   end
+      class Base
+        # Execute sink logic
+        #
+        # This method must be implemented by subclasses to provide the actual
+        # sink functionality. The pattern is to output the log request to the
+        # destination, then call the block to continue the sink chain.
+        #
+        # @param log_request [LogRequest] the log request to process
+        # @yield [LogRequest] yields the processed log request to the next sink
+        # @yieldreturn [LogRequest] the processed log request
+        # @return [LogRequest] the final processed log request
+        # @raise [NotImplementedError] if not overridden by subclass
+        def call(log_request, &block)
+          raise NotImplementedError, "#{self.class.name} must implement #call"
+        end
+
+        # Check if this sink should be applied to the given log request
+        #
+        # Override this method to provide conditional sink application
+        # based on log request properties like level, message, or context.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [Boolean] true if sink should be applied
+        def applicable?(log_request)
+          true
+        end
+
+        # Get sink name for logging and debugging
+        #
+        # @return [String] sink name
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Get sink configuration
+        #
+        # Override this method to provide sink-specific configuration.
+        #
+        # @return [Hash] sink configuration
+        def config
+          {}
+        end
+
+        private
+
+        # Pre-process the log request before outputting
+        #
+        # Override this method to modify the log request before it is output
+        # to the destination.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [LogRequest] the modified log request
+        def pre_process(log_request)
+          log_request
+        end
+
+        # Post-process the log request after outputting
+        #
+        # Override this method to perform any final processing after the
+        # log request has been output to the destination.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [LogRequest] the final log request
+        def post_process(log_request)
+          log_request
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/sinks/console.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "unified_file_sink"
+
+module Makit
+  module Logging
+    module Sinks
+      # Console sink for clean, colored log output
+      #
+      # This is a thin wrapper around UnifiedFileSink that provides a simple
+      # API for console output. It maintains backward compatibility while
+      # leveraging the unified logging architecture.
+      #
+      # @example Basic usage
+      #   console = Console.new
+      #   logger = Logger.new(sinks: [console])
+      #   logger.info("Processing started")
+      #   # Shows: → Processing started
+      #
+      # @example With custom formatter options
+      #   console = Console.new(show_timestamp: true, show_level: true)
+      #
+      # @example With custom formatter
+      #   console = Console.new(formatter: :text)
+      class Console < UnifiedFileSink
+        # @return [Symbol] the format being used
+        attr_reader :format
+
+        # Initialize console sink
+        #
+        # @param formatter [Symbol, String] formatter name (default: :console)
+        # @param show_timestamp [Boolean] whether to show timestamps (default: false)
+        # @param show_level [Boolean] whether to show log levels (default: false)
+        # @param formatter_options [Hash] additional formatter options
+        def initialize(formatter: :console, show_timestamp: false, show_level: false, **formatter_options)
+          @format = formatter.to_sym
+
+          # Build configuration for UnifiedFileSink
+          configuration = {
+            file: $stdout,
+            format: @format,
+            formatter_options: {
+              show_timestamp: show_timestamp,
+              show_level: show_level,
+            }.merge(formatter_options),
+          }
+
+          super(configurations: [configuration])
+        end
+
+        # Get sink configuration
+        #
+        # @return [Hash] sink configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            format: @format,
+            colors_enabled: true,
+            unified_sink: true,
+          }
+        end
+
+        # Check if this is a console sink (for compatibility)
+        #
+        # @return [Boolean] always true for Console sink
+        def console?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/sinks/file_sink.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "unified_file_sink"
+
+module Makit
+  module Logging
+    module Sinks
+      # File sink for writing log entries to files
+      #
+      # This sink is a thin wrapper around UnifiedFileSink that provides
+      # a simpler API for single-file logging. It maintains backward compatibility
+      # with the original FileSink interface while leveraging the more robust
+      # UnifiedFileSink implementation.
+      #
+      # @example Basic usage with default JSON formatter
+      #   file_sink = FileSink.new(log_file: "makit.log")
+      #   logger = Logger.new(sinks: [file_sink])
+      #   logger.info("Processing started")
+      #
+      # @example Using built-in formatters
+      #   file_sink = FileSink.new(
+      #     log_file: "makit.log",
+      #     formatter: :text
+      #   )
+      #
+      # @example Using custom formatter options
+      #   file_sink = FileSink.new(
+      #     log_file: "makit.log",
+      #     formatter: :json,
+      #     include_context: true,
+      #     include_metadata: true
+      #   )
+      class FileSink < Base
+        # @return [String] path to the log file
+        attr_reader :log_file
+        # @return [Symbol] the formatter format name
+        attr_reader :formatter
+        # @return [Boolean] whether to append to existing file (true) or overwrite (false)
+        attr_reader :append
+        # @return [UnifiedFileSink] the underlying unified sink
+        attr_reader :unified_sink
+
+        # Initialize file sink
+        #
+        # @param log_file [String] path to the log file
+        # @param formatter [Symbol, String] formatter format name
+        # @param append [Boolean] whether to append to existing file (true) or overwrite (false)
+        # @param include_context [Boolean] whether to include context in formatted output
+        # @param include_metadata [Boolean] whether to include metadata in formatted output
+        # @param show_timestamp [Boolean] whether to show timestamp in formatted output
+        # @param show_level [Boolean] whether to show log level in formatted output
+        def initialize(log_file: "makit.log", formatter: :json, append: true, **formatter_options)
+          @log_file = log_file
+          @formatter = formatter.to_sym
+          @append = append
+
+          # Create unified sink configuration
+          config = {
+            file: @log_file,
+            format: @formatter,
+            append: @append,
+          }.merge(formatter_options)
+
+          @unified_sink = UnifiedFileSink.new(configurations: [config])
+        end
+
+        # Execute sink logic to write log entry to file
+        #
+        # @param log_request [LogRequest] the log request to process
+        # @yield [LogRequest] yields the processed log request to the next sink
+        # @yieldreturn [LogRequest] the processed log request
+        # @return [LogRequest] the final processed log request
+        def call(log_request, &block)
+          @unified_sink.call(log_request, &block)
+        end
+
+        # Get sink configuration
+        #
+        # @return [Hash] sink configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            log_file: @log_file,
+            formatter: @formatter,
+            append: @append,
+            unified_config: @unified_sink.config,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/sinks/structured.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Makit
+  module Logging
+    module Sinks
+      # Structured sink for adding metadata to log requests
+      #
+      # This sink enriches log requests with structured metadata like
+      # process information, thread details, and other contextual data that
+      # can be useful for debugging and monitoring. It follows the same
+      # pattern as other sinks but focuses on data enrichment rather than output.
+      #
+      # @example Basic usage
+      #   structured_sink = Structured.new
+      #   logger = Logger.new(sinks: [structured_sink])
+      #   logger.info("Processing started")
+      #   # Adds metadata like process_id, thread_id, etc.
+      #
+      # @example With custom metadata
+      #   structured_sink = Structured.new(
+      #     custom_metadata: { environment: "production" }
+      #   )
+      class Structured < Base
+        # Initialize structured sink
+        #
+        # @param include_process_info [Boolean] whether to include process information
+        # @param include_thread_info [Boolean] whether to include thread information
+        # @param include_timing [Boolean] whether to include timing information
+        # @param custom_metadata [Hash] custom metadata to add to all log requests
+        def initialize(include_process_info: true, include_thread_info: true, include_timing: true, custom_metadata: {})
+          @include_process_info = include_process_info
+          @include_thread_info = include_thread_info
+          @include_timing = include_timing
+          @custom_metadata = custom_metadata.dup
+        end
+
+        # Execute sink logic to add structured metadata
+        #
+        # @param log_request [LogRequest] the log request to process
+        # @yield [LogRequest] yields the processed log request to the next sink
+        # @yieldreturn [LogRequest] the processed log request
+        # @return [LogRequest] the final processed log request
+        def call(log_request, &block)
+          add_structured_metadata(log_request)
+          block&.call(log_request) if block_given?
+          log_request
+        end
+
+        # Get sink configuration
+        #
+        # @return [Hash] sink configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            include_process_info: @include_process_info,
+            include_thread_info: @include_thread_info,
+            include_timing: @include_timing,
+            custom_metadata: @custom_metadata,
+          }
+        end
+
+        private
+
+        # Add structured metadata to the log request
+        #
+        # @param log_request [LogRequest] the log request to enrich
+        def add_structured_metadata(log_request)
+          metadata = {}
+
+          # Add process information
+          if @include_process_info
+            metadata.merge!(get_process_metadata)
+          end
+
+          # Add thread information
+          if @include_thread_info
+            metadata.merge!(get_thread_metadata)
+          end
+
+          # Add timing information
+          if @include_timing
+            metadata.merge!(get_timing_metadata)
+          end
+
+          # Add custom metadata
+          metadata.merge!(@custom_metadata)
+
+          # Add to log request
+          log_request.add_metadata(metadata)
+        end
+
+        # Get process-related metadata
+        #
+        # @return [Hash] process metadata
+        def get_process_metadata
+          {
+            process_id: ::Process.pid,
+            process_title: $0,
+            ruby_version: RUBY_VERSION,
+            ruby_platform: RUBY_PLATFORM,
+          }
+        end
+
+        # Get thread-related metadata
+        #
+        # @return [Hash] thread metadata
+        def get_thread_metadata
+          {
+            thread_id: Thread.current.object_id,
+            thread_name: Thread.current.name || "main",
+          }
+        end
+
+        # Get timing-related metadata
+        #
+        # @return [Hash] timing metadata
+        def get_timing_metadata
+          {
+            timestamp: Time.now.iso8601,
+            unix_timestamp: Time.now.to_i,
+            timezone: Time.now.zone,
+          }
+        end
+      end
+    end
+  end
+end