makit 0.0.112 → 0.0.128

data/lib/makit/logging/logger.rb

@@ -1,163 +1,199 @@
-# 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
+# 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
+      # @return [Symbol] current verbosity level
+      attr_reader :verbosity
+
+      # 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)
+      # @param verbosity [Symbol] verbosity level (:quiet, :normal, :verbose, :debug)
+      def initialize(sinks: [], level: :info, verbosity: :normal)
+        @sinks = sinks
+        @level = level
+        @verbosity = verbosity
+        @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
+      # @param verbosity [Symbol] verbosity level (:quiet, :normal, :verbose, :debug)
+      # @return [void]
+      def log(level, message, context = {}, verbosity: :normal)
+        return unless should_log?(level)
+        return unless should_show_verbosity?(verbosity)
+
+        log_request = LogRequest.new(level, message, context, verbosity: verbosity)
+        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
+
+      # Log a verbose message (only shown in verbose or debug mode)
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def verbose(message, context = {})
+        log(:info, message, context, verbosity: :verbose)
+      end
+
+      # Log a quiet message (shown even in quiet mode)
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def quiet(message, context = {})
+        log(:info, message, context, verbosity: :quiet)
+      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 = %i[debug info warn error fatal success]
+        levels.index(level) >= levels.index(@level)
+      end
+
+      # Check if a verbosity level should be shown
+      #
+      # @param verbosity [Symbol] the verbosity level to check
+      # @return [Boolean] true if the verbosity should be shown
+      def should_show_verbosity?(verbosity)
+        verbosity_levels = %i[quiet normal verbose debug]
+        verbosity_index = verbosity_levels.index(verbosity) || 1 # default to normal
+        current_index = verbosity_levels.index(@verbosity) || 1
+        verbosity_index <= current_index
+      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

@@ -1,91 +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
+# 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