makit 0.0.99 → 0.0.112

data/lib/makit/commands/middleware/command_logger.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../logging/logger"
+
+module Makit
+  module Commands
+    module Middleware
+      # Command-specific logging middleware with enhanced output handling
+      #
+      # This middleware provides specialized logging for command execution with
+      # enhanced output handling, performance tracking, and structured data
+      # logging. It's designed to work alongside the base Logger middleware
+      # to provide comprehensive command execution logging.
+      #
+      # @example Basic usage
+      #   logger = CommandLogger.new
+      #   runner = Runner.new(middleware: [logger])
+      #   result = runner.execute("git --version")
+      #
+      # @example With custom configuration
+      #   logger = CommandLogger.new(
+      #     log_stdout: true,
+      #     log_stderr: true,
+      #     log_performance: true,
+      #     max_output_lines: 50
+      #   )
+      class CommandLogger < Base
+        # @!attribute [r] logger
+        #   @return [Makit::Logging::Logger] the logging instance
+        attr_reader :logger
+
+        # Initialize command logging middleware.
+        #
+        # @param logger [Makit::Logging::Logger, nil] custom logger instance
+        # @param log_stdout [Boolean] whether to log stdout output
+        # @param log_stderr [Boolean] whether to log stderr output
+        # @param log_performance [Boolean] whether to log performance metrics
+        # @param max_output_lines [Integer] maximum lines of output to log
+        # @param log_level [Symbol] log level for command events
+        def initialize(
+          logger: nil,
+          log_stdout: false,
+          log_stderr: true,
+          log_performance: true,
+          max_output_lines: 100,
+          log_level: nil
+        )
+          @log_stdout = log_stdout
+          @log_stderr = log_stderr
+          @log_performance = log_performance
+          @max_output_lines = max_output_lines
+          @log_level = log_level || Makit::Logging.current_log_level
+
+          # Use the provided logger or create a new one with the specified log level
+          @logger = logger || Makit::Logging::Logger.new(
+            level: @log_level,
+            sinks: Makit::Logging.default_logger.sinks,
+          )
+        end
+
+        # Execute command with enhanced logging.
+        #
+        # @param request [Request] command request to execute
+        # @yield [Request] yields request to next middleware
+        # @return [Result] execution result
+        def call(request, &block)
+          start_time = Time.now
+          command_id = generate_command_id
+
+          # Log command start with enhanced context
+          log_command_start(request, command_id)
+
+          begin
+            # Execute the command
+            result = block.call(request)
+            duration = Time.now - start_time
+
+            # Log command completion with performance data
+            log_command_completion(request, result, duration, command_id)
+
+            # Log command output if configured
+            log_command_output(request, result, command_id)
+
+            result
+          rescue => error
+            duration = Time.now - start_time
+
+            # Log command error with full context
+            log_command_error(request, error, duration, command_id)
+
+            raise
+          end
+        end
+
+        # Check if this middleware applies to the given request.
+        #
+        # @param request [Request] command request
+        # @return [Boolean] true if middleware applies
+        def applicable?(request)
+          # Apply to all requests
+          true
+        end
+
+        # Get middleware configuration.
+        #
+        # @return [Hash] middleware configuration
+        def config
+          {
+            name: "CommandLogger",
+            description: "Enhanced command execution logging with output handling",
+            log_stdout: @log_stdout,
+            log_stderr: @log_stderr,
+            log_performance: @log_performance,
+            max_output_lines: @max_output_lines,
+            log_level: @log_level,
+            logger_class: @logger.class.name,
+          }
+        end
+
+        private
+
+        # Log command execution start with enhanced context.
+        #
+        # @param request [Request] command request
+        # @param command_id [String] unique command identifier
+        def log_command_start(request, command_id)
+          log_data = {
+            command_id: command_id,
+            command: request.command,
+            arguments: request.arguments,
+            working_directory: request.directory,
+            timeout: request.timeout,
+            environment: request.environment&.keys || [],
+            timestamp: Time.now.iso8601,
+          }
+
+          @logger.debug("Command execution started", log_data)
+        end
+
+        # Log command execution completion with performance data.
+        #
+        # @param request [Request] command request
+        # @param result [Result] execution result
+        # @param duration [Float] execution duration
+        # @param command_id [String] unique command identifier
+        def log_command_completion(request, result, duration, command_id)
+          log_data = {
+            command_id: command_id,
+            command: request.command,
+            success: result.success?,
+            exit_code: result.exit_code,
+            duration: duration,
+          }
+
+          # Add performance metrics if enabled
+          if @log_performance
+            log_data.merge!(
+              memory_usage: get_memory_usage,
+              timestamp: Time.now.iso8601,
+              output_size: calculate_output_size(result),
+            )
+          end
+
+          # Log detailed information at debug level
+          @logger.debug("Command completed successfully", log_data) if result.success?
+          @logger.debug("Command completed with errors", log_data) unless result.success?
+
+          # Log performance warnings
+          log_performance_warnings(request, result, duration, command_id) if @log_performance
+        end
+
+        # Log command output (stdout/stderr) with line limits.
+        #
+        # @param request [Request] command request
+        # @param result [Result] execution result
+        # @param command_id [String] unique command identifier
+        def log_command_output(request, result, command_id)
+          # Log stdout if enabled and present
+          if @log_stdout && result.stdout && !result.stdout.empty?
+            output_lines = result.stdout.split("\n")
+            truncated = output_lines.length > @max_output_lines
+
+            log_data = {
+              command_id: command_id,
+              command: request.command,
+              output: truncated ? output_lines.first(@max_output_lines).join("\n") : result.stdout,
+              total_lines: output_lines.length,
+              truncated: truncated,
+            }
+
+            @logger.debug("Command stdout", log_data)
+          end
+
+          # Log stderr if enabled and present
+          if @log_stderr && result.stderr && !result.stderr.empty?
+            output_lines = result.stderr.split("\n")
+            truncated = output_lines.length > @max_output_lines
+
+            log_data = {
+              command_id: command_id,
+              command: request.command,
+              output: truncated ? output_lines.first(@max_output_lines).join("\n") : result.stderr,
+              total_lines: output_lines.length,
+              truncated: truncated,
+            }
+
+            @logger.warn("Command stderr", log_data)
+          end
+        end
+
+        # Log command execution error with full context.
+        #
+        # @param request [Request] command request
+        # @param error [Exception] execution error
+        # @param duration [Float] execution duration
+        # @param command_id [String] unique command identifier
+        def log_command_error(request, error, duration, command_id)
+          log_data = {
+            command_id: command_id,
+            command: request.command,
+            arguments: request.arguments,
+            working_directory: request.directory,
+            environment: request.environment&.keys || [],
+            error_class: error.class.name,
+            error_message: error.message,
+            duration: duration,
+            backtrace: error.backtrace&.first(10),
+            timestamp: Time.now.iso8601,
+          }
+
+          @logger.error("Command execution failed", log_data)
+        end
+
+        # Log performance warnings for slow or resource-intensive commands.
+        #
+        # @param request [Request] command request
+        # @param result [Result] execution result
+        # @param duration [Float] execution duration
+        # @param command_id [String] unique command identifier
+        def log_performance_warnings(request, result, duration, command_id)
+          # Log slow commands
+          if duration > 5.0
+            @logger.warn("Slow command detected",
+                         command_id: command_id,
+                         command: request.command,
+                         duration: duration,
+                         threshold: "5.0s")
+          end
+
+          # Log commands with large output
+          output_size = calculate_output_size(result)
+          if output_size > 100_000 # 100KB
+            @logger.warn("Command with large output detected",
+                         command_id: command_id,
+                         command: request.command,
+                         output_size: "#{output_size / 1024}KB",
+                         threshold: "100KB")
+          end
+
+          # Log commands with high exit codes (potential errors)
+          if result.exit_code > 0
+            @logger.debug("Command completed with non-zero exit code",
+                         command_id: command_id,
+                         command: request.command,
+                         exit_code: result.exit_code,
+                         success: result.success?)
+          end
+        end
+
+        # Calculate total output size (stdout + stderr).
+        #
+        # @param result [Result] execution result
+        # @return [Integer] total output size in bytes
+        def calculate_output_size(result)
+          size = 0
+          size += result.stdout&.bytesize || 0
+          size += result.stderr&.bytesize || 0
+          size
+        end
+
+        # Generate a unique command identifier.
+        #
+        # @return [String] unique command ID
+        def generate_command_id
+          "#{::Process.pid}-#{Time.now.to_f}-#{rand(1000)}"
+        end
+
+        # Get current memory usage (if available).
+        #
+        # @return [String, nil] memory usage string or nil if unavailable
+        def get_memory_usage
+          # Try to get memory usage on different platforms
+          if RUBY_PLATFORM.match?(/mswin|mingw/)
+            # Windows - try to get memory usage
+            begin
+              # This is a simplified approach for Windows
+              "Unknown"
+            rescue
+              nil
+            end
+          else
+            # Unix-like systems
+            begin
+              # Try to get memory usage from /proc/self/status
+              if File.exist?("/proc/self/status")
+                status = File.read("/proc/self/status")
+                if match = status.match(/VmRSS:\s+(\d+)\s+kB/)
+                  "#{match[1].to_i / 1024}MB"
+                end
+              end
+            rescue
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands/middleware/unified_logger.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Makit
+  module Commands
+    module Middleware
+      # Unified logging middleware that consolidates all command logging functionality
+      #
+      # This middleware replaces the need for multiple separate logging middleware
+      # by providing a single, comprehensive logging solution that handles console
+      # display, file logging, and structured logging through the Makit::Logging system.
+      #
+      # @example Basic usage
+      #   logger = UnifiedLogger.new
+      #   runner = Runner.new(middleware: [logger])
+      #   result = runner.execute("git --version")
+      #
+      # @example With custom logger configuration
+      #   custom_logger = Makit::Logging::Logger.new(
+      #     sinks: [
+      #       Makit::Logging::Sinks::Console.new,
+      #       Makit::Logging::Sinks::FileSink.new(log_file: "artifacts/commands.log")
+      #     ]
+      #   )
+      #   logger = UnifiedLogger.new(logger: custom_logger)
+      #   runner = Runner.new(middleware: [logger])
+      class UnifiedLogger < Base
+        # @!attribute [r] logger
+        #   @return [Makit::Logging::Logger] the logging instance
+        attr_reader :logger
+
+        # Initialize unified logging middleware.
+        #
+        # @param logger [Makit::Logging::Logger, nil] custom logger instance
+        # @param log_to_console [Boolean] whether to log to console
+        # @param log_to_file [Boolean] whether to log to file
+        # @param log_performance [Boolean] whether to log performance metrics
+        # @param log_output [Boolean] whether to log command output
+        def initialize(logger: nil, log_to_console: true, log_to_file: true, log_performance: true, log_output: false)
+          @logger = logger || create_default_logger(log_to_console, log_to_file)
+          @log_performance = log_performance
+          @log_output = log_output
+        end
+
+        # Execute command with unified logging.
+        #
+        # @param request [Request] command request to execute
+        # @yield [Request] yields request to next middleware
+        # @return [Result] execution result
+        def call(request, &block)
+          command_id = generate_command_id
+          start_time = Time.now
+
+          # Log command start
+          log_command_start(request, command_id)
+
+          begin
+            # Execute the command
+            result = block.call(request)
+            duration = Time.now - start_time
+
+            # Log command completion
+            log_command_completion(request, result, duration, command_id)
+
+            result
+          rescue => error
+            duration = Time.now - start_time
+
+            # Log command error
+            log_command_error(request, error, duration, command_id)
+
+            raise
+          end
+        end
+
+        # Check if this middleware applies to the given request.
+        #
+        # @param request [Request] command request
+        # @return [Boolean] true if middleware applies
+        def applicable?(request)
+          true
+        end
+
+        # Get middleware configuration.
+        #
+        # @return [Hash] middleware configuration
+        def config
+          {
+            name: "UnifiedLogger",
+            description: "Unified logging for command execution with console and file output",
+            log_performance: @log_performance,
+            log_output: @log_output,
+            logger_class: @logger.class.name,
+          }
+        end
+
+        private
+
+        # Create default logger with console and file output
+        #
+        # @param log_to_console [Boolean] whether to log to console
+        # @param log_to_file [Boolean] whether to log to file
+        # @return [Makit::Logging::Logger] configured logger
+        def create_default_logger(log_to_console, log_to_file)
+          sinks = []
+
+          if log_to_console
+            sinks << Makit::Logging::Sinks::Console.new
+          end
+
+          if log_to_file
+            sinks << Makit::Logging::Sinks::FileSink.new(
+              log_file: "artifacts/commands.log",
+              formatter: :json,
+              include_metadata: true,
+            )
+          end
+
+          Makit::Logging::Logger.new(sinks: sinks)
+        end
+
+        # Log command execution start.
+        #
+        # @param request [Request] command request
+        # @param command_id [String] unique command identifier
+        def log_command_start(request, command_id)
+          @logger.info("Command execution started", {
+            command_id: command_id,
+            command: request.command,
+            arguments: request.arguments,
+            working_directory: request.directory,
+            timeout: request.timeout,
+            environment: request.environment&.keys || [],
+          })
+        end
+
+        # Log command execution completion.
+        #
+        # @param request [Request] command request
+        # @param result [Result] execution result
+        # @param duration [Float] execution duration
+        # @param command_id [String] unique command identifier
+        def log_command_completion(request, result, duration, command_id)
+          log_data = {
+            command_id: command_id,
+            command: request.command,
+            arguments: request.arguments,
+            success: result.success?,
+            exit_code: result.exit_code,
+            duration: duration,
+            working_directory: request.directory,
+          }
+
+          # Add performance metrics if enabled
+          if @log_performance
+            log_data.merge!(
+              memory_usage: get_memory_usage,
+              timestamp: Time.now.iso8601,
+            )
+          end
+
+          # Add output if enabled and present
+          if @log_output
+            log_data[:stdout_lines] = result.stdout&.split("\n")&.length || 0
+            log_data[:stderr_lines] = result.stderr&.split("\n")&.length || 0
+            log_data[:stdout] = result.stdout if result.stdout && !result.stdout.empty?
+            log_data[:stderr] = result.stderr if result.stderr && !result.stderr.empty?
+          end
+
+          # Log at appropriate level based on success
+          if result.success?
+            @logger.success("Command completed successfully", log_data)
+          else
+            @logger.error("Command completed with errors", log_data)
+          end
+
+          # Log slow commands
+          if @log_performance && duration > 1.0
+            @logger.warn("Slow command detected",
+                         command_id: command_id,
+                         command: request.command,
+                         duration: duration)
+          end
+        end
+
+        # Log command execution error.
+        #
+        # @param request [Request] command request
+        # @param error [Exception] execution error
+        # @param duration [Float] execution duration
+        # @param command_id [String] unique command identifier
+        def log_command_error(request, error, duration, command_id)
+          @logger.error("Command execution failed", {
+            command_id: command_id,
+            command: request.command,
+            arguments: request.arguments,
+            working_directory: request.directory,
+            error_class: error.class.name,
+            error_message: error.message,
+            duration: duration,
+            backtrace: error.backtrace&.first(5),
+          })
+        end
+
+        # Generate a unique command identifier.
+        #
+        # @return [String] unique command ID
+        def generate_command_id
+          "#{::Process.pid}-#{Time.now.to_f}-#{rand(1000)}"
+        end
+
+        # Get current memory usage (if available).
+        #
+        # @return [String, nil] memory usage string or nil if unavailable
+        def get_memory_usage
+          # Try to get memory usage on different platforms
+          if RUBY_PLATFORM.match?(/mswin|mingw/)
+            # Windows - try to get memory usage
+            begin
+              "Unknown"
+            rescue
+              nil
+            end
+          else
+            # Unix-like systems
+            begin
+              # Try to get memory usage from /proc/self/status
+              if File.exist?("/proc/self/status")
+                status = File.read("/proc/self/status")
+                if match = status.match(/VmRSS:\s+(\d+)\s+kB/)
+                  "#{match[1].to_i / 1024}MB"
+                end
+              end
+            rescue
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end