makit 0.0.111 → 0.0.126

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

@@ -1,129 +1,123 @@
-# 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
+# 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
+          metadata.merge!(get_process_metadata) if @include_process_info
+
+          # Add thread information
+          metadata.merge!(get_thread_metadata) if @include_thread_info
+
+          # Add timing information
+          metadata.merge!(get_timing_metadata) if @include_timing
+
+          # 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: $PROGRAM_NAME,
+            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

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

@@ -111,9 +111,12 @@ module Makit
         def validate_single_configuration(config, index)
           raise ArgumentError, "configuration #{index} must be a hash" unless config.is_a?(Hash)
 
-          required_keys = [:file, :format]
+          required_keys = %i[file format]
           missing_keys = required_keys - config.keys
-          raise ArgumentError, "configuration #{index} missing required keys: #{missing_keys.join(", ")}" unless missing_keys.empty?
+          unless missing_keys.empty?
+            raise ArgumentError,
+                  "configuration #{index} missing required keys: #{missing_keys.join(", ")}"
+          end
 
           # Validate file
           file = config[:file]
@@ -132,9 +135,9 @@ module Makit
             raise ArgumentError, "configuration #{index} min_level must be a valid log level"
           end
 
-          if config[:max_level] && !valid_log_level?(config[:max_level])
-            raise ArgumentError, "configuration #{index} max_level must be a valid log level"
-          end
+          return unless config[:max_level] && !valid_log_level?(config[:max_level])
+
+          raise ArgumentError, "configuration #{index} max_level must be a valid log level"
         end
 
         # Check if log level is valid
@@ -163,36 +166,34 @@ module Makit
               formatter_class = FormatRegistry.get(format)
 
               # Handle different formatter initialization patterns
-              if formatter_class == Formatters::ConsoleFormatter
-                # ConsoleFormatter expects keyword arguments
-                @formatters[index] = formatter_class.new(
-                  show_timestamp: formatter_options[:show_timestamp] || false,
-                  show_level: formatter_options[:show_level] || false,
-                )
-              elsif formatter_class == Formatters::TextFormatter
-                # TextFormatter expects keyword arguments
-                @formatters[index] = formatter_class.new(
-                  timestamp_format: formatter_options[:timestamp_format] || "%Y-%m-%d %H:%M:%S",
-                  include_context: formatter_options[:include_context] || false,
-                )
-              elsif formatter_class == Formatters::JsonFormatter
-                # JsonFormatter expects keyword arguments
-                @formatters[index] = formatter_class.new(
-                  options: formatter_options,
-                )
-              elsif formatter_class == Formatters::PlainTextFormatter
-                # PlainTextFormatter expects keyword arguments
-                @formatters[index] = formatter_class.new(
-                  include_context: formatter_options[:include_context] || false,
-                )
-              else
-                # Other formatters expect hash or no arguments
-                if formatter_options.empty?
-                  @formatters[index] = formatter_class.new
+              @formatters[index] = if formatter_class == Formatters::ConsoleFormatter
+                  # ConsoleFormatter expects keyword arguments
+                  formatter_class.new(
+                    show_timestamp: formatter_options[:show_timestamp] || false,
+                    show_level: formatter_options[:show_level] || false,
+                  )
+                elsif formatter_class == Formatters::TextFormatter
+                  # TextFormatter expects keyword arguments
+                  formatter_class.new(
+                    timestamp_format: formatter_options[:timestamp_format] || "%Y-%m-%d %H:%M:%S",
+                    include_context: formatter_options[:include_context] || false,
+                  )
+                elsif formatter_class == Formatters::JsonFormatter
+                  # JsonFormatter expects keyword arguments
+                  formatter_class.new(
+                    options: formatter_options,
+                  )
+                elsif formatter_class == Formatters::PlainTextFormatter
+                  # PlainTextFormatter expects keyword arguments
+                  formatter_class.new(
+                    include_context: formatter_options[:include_context] || false,
+                  )
+                elsif formatter_options.empty?
+                  # Other formatters expect hash or no arguments
+                  formatter_class.new
                 else
-                  @formatters[index] = formatter_class.new(formatter_options)
+                  formatter_class.new(formatter_options)
                 end
-              end
             rescue ArgumentError => e
               raise ArgumentError, "configuration #{index} has invalid format '#{format}': #{e.message}"
             end
@@ -211,7 +212,7 @@ module Makit
               FileUtils.mkdir_p(File.dirname(file)) unless File.dirname(file) == "."
 
               # Open file with appropriate mode
-              mode = config[:append] != false ? "a" : "w"
+              mode = config[:append] == false ? "w" : "a"
               @files[index] = File.open(file, mode)
             else
               # Use IO object directly
@@ -244,18 +245,12 @@ module Makit
         # @return [Boolean] true if should output
         def should_output?(log_request, config)
           # Check level filtering
-          if config[:min_level] && !level_greater_or_equal?(log_request.level, config[:min_level])
-            return false
-          end
+          return false if config[:min_level] && !level_greater_or_equal?(log_request.level, config[:min_level])
 
-          if config[:max_level] && !level_less_or_equal?(log_request.level, config[:max_level])
-            return false
-          end
+          return false if config[:max_level] && !level_less_or_equal?(log_request.level, config[:max_level])
 
           # Check custom condition
-          if config[:condition] && !config[:condition].call(log_request)
-            return false
-          end
+          return false if config[:condition] && !config[:condition].call(log_request)
 
           true
         end
@@ -291,9 +286,7 @@ module Makit
           sanitized.delete(:condition)
 
           # Convert IO objects to string representation
-          if sanitized[:file].is_a?(IO)
-            sanitized[:file] = "<#{sanitized[:file].class.name}>"
-          end
+          sanitized[:file] = "<#{sanitized[:file].class.name}>" if sanitized[:file].is_a?(IO)
 
           sanitized
         end

data/lib/makit/logging.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 require "logger"
-require "colorize"
+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 "symbols"
 require_relative "logging/logger"
 require_relative "logging/log_request"
@@ -66,9 +75,25 @@ module Makit
     def self.current_log_level
       env_level = ENV["LOG_LEVEL"]&.downcase&.to_sym
       return env_level if env_level && LOG_LEVELS.key?(env_level)
+
       DEFAULT_LOG_LEVEL
     end
 
+    # Get the current verbosity level from environment or use default
+    def self.current_verbosity
+      env_verbosity = ENV["VERBOSITY"]&.downcase&.to_sym
+      return env_verbosity if env_verbosity && %i[quiet normal verbose debug].include?(env_verbosity)
+
+      :normal
+    end
+
+    # Get the current verbosity level from the default logger
+    #
+    # @return [Symbol] current verbosity level (:quiet, :normal, :verbose, :debug)
+    def self.verbosity
+      DEFAULT_LOGGER.verbosity
+    end
+
     # Logs the duration of a rake task to a file
     #
     # This method calculates the elapsed time since the STARTTIME constant was set
@@ -377,6 +402,7 @@ module Makit
     # This replaces the previous multi-sink approach with a single, configurable sink
     DEFAULT_LOGGER = Logger.new(
       level: current_log_level,
+      verbosity: current_verbosity,
       sinks: [
         Sinks::UnifiedFileSink.new(
           configurations: [
@@ -464,6 +490,24 @@ module Makit
       DEFAULT_LOGGER.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 self.verbose(message, context = {})
+      DEFAULT_LOGGER.verbose(message, context)
+    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 self.quiet(message, context = {})
+      DEFAULT_LOGGER.quiet(message, context)
+    end
+
     # Create a logger with environment-specific configuration
     #
     # @param environment [Symbol] environment name (:development, :production, :test, :ci)

data/lib/makit/mp/project_mp.rb

@@ -154,10 +154,10 @@ module Makit
           next if project.os == "windows" && !Makit::Environment.is_windows?
 
           project.commands.each do |command|
-            newest_file_timestamp = Makit::Directory.get_newest_file_timestamp(project.output)
+            Makit::Directory.get_newest_file_timestamp(project.output)
             # newest_file = Makit::Directory::get_newest_file_or_now(project.output)
-            command_request = Makit::RUNNER.parse_command_request(command)
-            RUNNER.cache_run(command_request, newest_file_timestamp)
+            command_request = Makit::Commands::Request.from_string(command)
+            Makit::Commands::Runner.default.execute(command_request)
           end
         end
       end
@@ -167,10 +167,10 @@ module Makit
           next if project.os == "windows" && !Makit::Environment.is_windows?
 
           project.commands.each do |command|
-            newest_file_timestamp = Makit::Directory.get_newest_file_timestamp(project.output)
+            Makit::Directory.get_newest_file_timestamp(project.output)
             # newest_file = Makit::Directory::get_newest_file_or_now(project.output)
-            command_request = Makit::RUNNER.parse_command_request(command)
-            RUNNER.cache_run(command_request, newest_file_timestamp)
+            command_request = Makit::Commands::Request.from_string(command)
+            Makit::Commands::Runner.default.execute(command_request)
           end
           project.build_args.each do |build_arg|
             project_path = File.join(project.output, "#{project.name}.csproj")