makit 0.0.111 → 0.0.112

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

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