makit 0.0.112 → 0.0.126

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

@@ -1,320 +1,311 @@
-# 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
+# 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 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
+        def initialize(
+          log_stdout: false,
+          log_stderr: true,
+          log_performance: true,
+          max_output_lines: 100
+        )
+          @log_stdout = log_stdout
+          @log_stderr = log_stderr
+          @log_performance = log_performance
+          @max_output_lines = max_output_lines
+
+          # Use the default logger for all logging
+          @logger = Makit::Logging.default_logger
+        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 StandardError => e
+            duration = Time.now - start_time
+
+            # Log command error with full context
+            log_command_error(request, e, 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: "Command execution logging with performance tracking and output handling",
+            log_stdout: @log_stdout,
+            log_stderr: @log_stderr,
+            log_performance: @log_performance,
+            max_output_lines: @max_output_lines,
+            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
+          return unless @log_stderr && result.stderr && !result.stderr.empty?
+
+          output_lines = result.stderr.split("\n")
+          truncated = output_lines.length > @max_output_lines
+
+          {
+            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
+
+        # 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)
+          return unless result.exit_code.positive?
+
+          @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
+
+        # 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 StandardError
+              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 StandardError
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end