vector_mcp 0.3.0 → 0.3.1

data/lib/vector_mcp/logging/filters/component.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "set"
+
+module VectorMCP
+  module Logging
+    module Filters
+      class Component
+        def initialize(allowed_components = nil, blocked_components = nil)
+          @allowed_components = normalize_components(allowed_components)
+          @blocked_components = normalize_components(blocked_components)
+        end
+
+        def accept?(log_entry)
+          return false if blocked?(log_entry.component)
+          return true if @allowed_components.nil?
+
+          allowed?(log_entry.component)
+        end
+
+        def allow_component(component)
+          @allowed_components ||= Set.new
+          @allowed_components.add(component.to_s)
+        end
+
+        def block_component(component)
+          @blocked_components ||= Set.new
+          @blocked_components.add(component.to_s)
+        end
+
+        def remove_component_filter(component)
+          @allowed_components&.delete(component.to_s)
+          @blocked_components&.delete(component.to_s)
+        end
+
+        private
+
+        def allowed?(component)
+          return true if @allowed_components.nil?
+
+          @allowed_components.include?(component) ||
+            @allowed_components.any? { |pattern| component.start_with?(pattern) }
+        end
+
+        def blocked?(component)
+          return false if @blocked_components.nil?
+
+          @blocked_components.include?(component) ||
+            @blocked_components.any? { |pattern| component.start_with?(pattern) }
+        end
+
+        def normalize_components(components)
+          case components
+          when nil
+            nil
+          when String
+            Set.new([components])
+          when Array
+            Set.new(components.map(&:to_s))
+          when Set
+            components
+          else
+            Set.new([components.to_s])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/filters/level.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module VectorMCP
+  module Logging
+    module Filters
+      class Level
+        def initialize(min_level)
+          @min_level = min_level.is_a?(Integer) ? min_level : Logging.level_value(min_level)
+        end
+
+        def accept?(log_entry)
+          log_entry.level >= @min_level
+        end
+
+        def min_level=(new_level)
+          @min_level = new_level.is_a?(Integer) ? new_level : Logging.level_value(new_level)
+        end
+
+        attr_reader :min_level
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/formatters/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module VectorMCP
+  module Logging
+    module Formatters
+      class Base
+        def initialize(options = {})
+          @options = options
+        end
+
+        def format(log_entry)
+          raise NotImplementedError, "Subclasses must implement #format"
+        end
+
+        protected
+
+        def format_timestamp(timestamp)
+          timestamp.strftime("%Y-%m-%d %H:%M:%S.%#{Constants::TIMESTAMP_PRECISION}N")
+        end
+
+        def format_level(level_name, width = Constants::DEFAULT_LEVEL_WIDTH)
+          level_name.ljust(width)
+        end
+
+        def format_component(component, width = Constants::DEFAULT_COMPONENT_WIDTH)
+          if component.length > width
+            "#{component[0..(width - Constants::TRUNCATION_SUFFIX_LENGTH)]}..."
+          else
+            component.ljust(width)
+          end
+        end
+
+        def format_context(context)
+          return "" if context.empty?
+
+          pairs = context.map do |key, value|
+            "#{key}=#{value}"
+          end
+          " (#{pairs.join(", ")})"
+        end
+
+        def truncate_message(message, max_length = Constants::DEFAULT_MAX_MESSAGE_LENGTH)
+          return message if message.length <= max_length
+
+          "#{message[0..(max_length - Constants::TRUNCATION_SUFFIX_LENGTH)]}..."
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/formatters/json.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../constants"
+
+module VectorMCP
+  module Logging
+    module Formatters
+      class Json < Base
+        def initialize(options = {})
+          super
+          @pretty = options.fetch(:pretty, false)
+          @include_thread = options.fetch(:include_thread, false)
+        end
+
+        def format(log_entry)
+          data = {
+            timestamp: log_entry.timestamp.iso8601(Constants::TIMESTAMP_PRECISION),
+            level: log_entry.level_name,
+            component: log_entry.component,
+            message: log_entry.message
+          }
+
+          data[:context] = log_entry.context unless log_entry.context.empty?
+          data[:thread_id] = log_entry.thread_id if @include_thread
+
+          if @pretty
+            "#{JSON.pretty_generate(data)}\n"
+          else
+            "#{JSON.generate(data)}\n"
+          end
+        rescue JSON::GeneratorError, JSON::NestingError => e
+          fallback_format(log_entry, e)
+        end
+
+        private
+
+        def fallback_format(log_entry, error)
+          safe_data = {
+            timestamp: log_entry.timestamp.iso8601(Constants::TIMESTAMP_PRECISION),
+            level: log_entry.level_name,
+            component: log_entry.component,
+            message: "JSON serialization failed: #{error.message}",
+            original_message: log_entry.message.to_s,
+            context: sanitize_context(log_entry.context)
+          }
+
+          "#{JSON.generate(safe_data)}\n"
+        end
+
+        def sanitize_context(context, depth = 0)
+          return "<max_depth_reached>" if depth > Constants::MAX_SERIALIZATION_DEPTH
+          return {} unless context.is_a?(Hash)
+
+          context.each_with_object({}) do |(key, value), sanitized|
+            sanitized[key.to_s] = sanitize_value(value, depth + 1)
+          end
+        rescue StandardError
+          { "<sanitization_error>" => true }
+        end
+
+        def sanitize_value(value, depth = 0)
+          return "<max_depth_reached>" if depth > Constants::MAX_SERIALIZATION_DEPTH
+
+          case value
+          when String, Numeric, TrueClass, FalseClass, NilClass
+            value
+          when Array
+            return "<complex_array>" if depth > Constants::MAX_ARRAY_SERIALIZATION_DEPTH
+
+            value.first(Constants::MAX_ARRAY_ELEMENTS_TO_SERIALIZE).map { |v| sanitize_value(v, depth + 1) }
+          when Hash
+            sanitize_context(value, depth)
+          else
+            value.to_s
+          end
+        rescue StandardError
+          "<serialization_error>"
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/formatters/text.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module VectorMCP
+  module Logging
+    module Formatters
+      class Text < Base
+        COLORS = {
+          TRACE: "\e[90m",    # gray
+          DEBUG: "\e[36m",    # cyan
+          INFO: "\e[32m",     # green
+          WARN: "\e[33m",     # yellow
+          ERROR: "\e[31m",    # red
+          FATAL: "\e[35m",    # magenta
+          SECURITY: "\e[1;31m" # bold red
+        }.freeze
+
+        RESET_COLOR = "\e[0m"
+
+        def initialize(options = {})
+          super
+          @colorize = options.fetch(:colorize, true)
+          @include_timestamp = options.fetch(:include_timestamp, true)
+          @include_thread = options.fetch(:include_thread, false)
+          @include_component = options.fetch(:include_component, true)
+          @max_message_length = options.fetch(:max_message_length, Constants::DEFAULT_MAX_MESSAGE_LENGTH)
+        end
+
+        def format(log_entry)
+          parts = []
+
+          parts << format_timestamp_part(log_entry.timestamp) if @include_timestamp
+
+          parts << format_level_part(log_entry.level_name)
+
+          parts << format_component_part(log_entry.component) if @include_component
+
+          parts << format_thread_part(log_entry.thread_id) if @include_thread
+
+          message = truncate_message(log_entry.message, @max_message_length)
+          context_str = format_context(log_entry.context)
+
+          "#{parts.join(" ")} #{message}#{context_str}\n"
+        end
+
+        private
+
+        def format_timestamp_part(timestamp)
+          "[#{format_timestamp(timestamp)}]"
+        end
+
+        def format_level_part(level_name)
+          level_str = format_level(level_name.to_s, Constants::DEFAULT_LEVEL_WIDTH)
+          if @colorize && COLORS[level_name.to_sym]
+            "#{COLORS[level_name.to_sym]}#{level_str}#{RESET_COLOR}"
+          else
+            level_str
+          end
+        end
+
+        def format_component_part(component)
+          format_component(component, Constants::DEFAULT_COMPONENT_WIDTH)
+        end
+
+        def format_thread_part(thread_id)
+          "[#{thread_id}]"
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/outputs/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module VectorMCP
+  module Logging
+    module Outputs
+      class Base
+        attr_reader :formatter, :config
+
+        def initialize(config = {})
+          @config = config
+          @formatter = create_formatter
+          @closed = false
+        end
+
+        def write(log_entry)
+          return if @closed
+
+          formatted_message = @formatter.format(log_entry)
+          write_formatted(formatted_message)
+        rescue StandardError => e
+          fallback_write("Logging output error: #{e.message}\n")
+        end
+
+        def close
+          @closed = true
+        end
+
+        def closed?
+          @closed
+        end
+
+        def reconfigure
+          @formatter = create_formatter
+        end
+
+        protected
+
+        def write_formatted(message)
+          raise NotImplementedError, "Subclasses must implement #write_formatted"
+        end
+
+        def fallback_write(message)
+          $stderr.write(message)
+        end
+
+        private
+
+        def create_formatter
+          format_type = @config[:format] || "text"
+          formatter_options = @config.except(:format)
+
+          case format_type.to_s.downcase
+          when "json"
+            Formatters::Json.new(formatter_options)
+          when "text"
+            Formatters::Text.new(formatter_options)
+          else
+            raise OutputError, "Unknown formatter type: #{format_type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/outputs/console.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module VectorMCP
+  module Logging
+    module Outputs
+      class Console < Base
+        def initialize(config = {})
+          super
+          @stream = determine_stream
+          @mutex = Mutex.new
+        end
+
+        protected
+
+        def write_formatted(message)
+          @mutex.synchronize do
+            @stream.write(message)
+            @stream.flush if @stream.respond_to?(:flush)
+          end
+        end
+
+        private
+
+        def determine_stream
+          case @config[:stream]&.to_s&.downcase
+          when "stdout"
+            $stdout
+          else
+            $stderr # Default to stderr for logging
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging/outputs/file.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "date"
+
+module VectorMCP
+  module Logging
+    module Outputs
+      class File < Base
+        def initialize(config = {})
+          super
+          @path = @config[:path] or raise OutputError, "File path required"
+          @max_size = parse_size(@config[:max_size] || "100MB")
+          @max_files = @config[:max_files] || 7
+          @rotation = @config[:rotation] || "daily"
+          @mutex = Mutex.new
+          @file = nil
+          @current_date = nil
+
+          ensure_directory_exists
+          open_file
+        end
+
+        def close
+          @mutex.synchronize do
+            @file&.close
+            @file = nil
+          end
+          super
+        end
+
+        protected
+
+        def write_formatted(message)
+          @mutex.synchronize do
+            rotate_if_needed
+            @file.write(message)
+            @file.flush
+          end
+        end
+
+        private
+
+        def ensure_directory_exists
+          dir = ::File.dirname(@path)
+          FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+        rescue StandardError => e
+          raise OutputError, "Cannot create log directory #{dir}: #{e.message}"
+        end
+
+        def open_file
+          @file = ::File.open(current_log_path, "a")
+          @file.sync = true
+          @current_date = Date.today if daily_rotation?
+        rescue StandardError => e
+          raise OutputError, "Cannot open log file #{current_log_path}: #{e.message}"
+        end
+
+        def current_log_path
+          if daily_rotation?
+            base, ext = split_path(@path)
+            "#{base}_#{Date.today.strftime("%Y%m%d")}#{ext}"
+          else
+            @path
+          end
+        end
+
+        def rotate_if_needed
+          return unless should_rotate?
+
+          rotate_file
+          open_file
+        end
+
+        def should_rotate?
+          return false unless @file
+
+          case @rotation
+          when "daily"
+            daily_rotation? && @current_date != Date.today
+          when "size"
+            @file.size >= @max_size
+          else
+            false
+          end
+        end
+
+        def rotate_file
+          @file&.close
+
+          if daily_rotation?
+            cleanup_old_files
+          else
+            rotate_numbered_files
+          end
+        end
+
+        def daily_rotation?
+          @rotation == "daily"
+        end
+
+        def rotate_numbered_files
+          return unless ::File.exist?(@path)
+
+          (@max_files - 1).downto(1) do |i|
+            old_file = "#{@path}.#{i}"
+            new_file = "#{@path}.#{i + 1}"
+
+            ::File.rename(old_file, new_file) if ::File.exist?(old_file)
+          end
+
+          ::File.rename(@path, "#{@path}.1")
+        end
+
+        def cleanup_old_files
+          base, ext = split_path(@path)
+          pattern = "#{base}_*#{ext}"
+
+          old_files = Dir.glob(pattern).reverse
+          files_to_remove = old_files[@max_files..] || []
+
+          files_to_remove.each do |file|
+            ::File.unlink(file)
+          rescue StandardError => e
+            fallback_write("Warning: Could not remove old log file #{file}: #{e.message}\n")
+          end
+        end
+
+        def split_path(path)
+          ext = ::File.extname(path)
+          base = path.chomp(ext)
+          [base, ext]
+        end
+
+        def parse_size(size_str)
+          size_str = size_str.to_s.upcase
+
+          raise OutputError, "Invalid size format: #{size_str}" unless size_str =~ /\A(\d+)(KB|MB|GB)?\z/
+
+          number = ::Regexp.last_match(1).to_i
+          unit = ::Regexp.last_match(2) || "B"
+
+          case unit
+          when "KB"
+            number * 1024
+          when "MB"
+            number * 1024 * 1024
+          when "GB"
+            number * 1024 * 1024 * 1024
+          else
+            number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vector_mcp/logging.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "logging/constants"
+require_relative "logging/core"
+require_relative "logging/configuration"
+require_relative "logging/component"
+require_relative "logging/formatters/base"
+require_relative "logging/formatters/text"
+require_relative "logging/formatters/json"
+require_relative "logging/outputs/base"
+require_relative "logging/outputs/console"
+require_relative "logging/outputs/file"
+require_relative "logging/filters/level"
+require_relative "logging/filters/component"
+
+module VectorMCP
+  module Logging
+    class Error < StandardError; end
+    class ConfigurationError < Error; end
+    class FormatterError < Error; end
+    class OutputError < Error; end
+
+    LEVELS = {
+      TRACE: 0,
+      DEBUG: 1,
+      INFO: 2,
+      WARN: 3,
+      ERROR: 4,
+      FATAL: 5,
+      SECURITY: 6
+    }.freeze
+
+    LEVEL_NAMES = LEVELS.invert.freeze
+
+    def self.level_name(level)
+      (LEVEL_NAMES[level] || "UNKNOWN").to_s
+    end
+
+    def self.level_value(name)
+      LEVELS[name.to_s.upcase.to_sym] || LEVELS[:INFO]
+    end
+
+    class LogEntry
+      attr_reader :timestamp, :level, :component, :message, :context, :thread_id
+
+      def initialize(attributes = {})
+        @timestamp = attributes[:timestamp]
+        @level = attributes[:level]
+        @component = attributes[:component]
+        @message = attributes[:message]
+        @context = attributes[:context] || {}
+        @thread_id = attributes[:thread_id]
+      end
+
+      def level_name
+        Logging.level_name(@level)
+      end
+
+      def to_h
+        {
+          timestamp: @timestamp.iso8601(Constants::TIMESTAMP_PRECISION),
+          level: level_name,
+          component: @component,
+          message: @message,
+          context: @context,
+          thread_id: @thread_id
+        }
+      end
+    end
+  end
+end

data/lib/vector_mcp/security/auth_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module VectorMCP
+  module Security
+    # Manages authentication strategies for VectorMCP servers
+    # Provides opt-in authentication with zero configuration by default
+    class AuthManager
+      attr_reader :strategies, :enabled, :default_strategy
+
+      def initialize
+        @strategies = {}
+        @enabled = false
+        @default_strategy = nil
+      end
+
+      # Enable authentication with optional default strategy
+      # @param default_strategy [Symbol] the default authentication strategy to use
+      def enable!(default_strategy: :api_key)
+        @enabled = true
+        @default_strategy = default_strategy
+      end
+
+      # Disable authentication (return to pass-through mode)
+      def disable!
+        @enabled = false
+        @default_strategy = nil
+      end
+
+      # Add an authentication strategy
+      # @param name [Symbol] the strategy name
+      # @param strategy [Object] the strategy instance
+      def add_strategy(name, strategy)
+        @strategies[name] = strategy
+      end
+
+      # Remove an authentication strategy
+      # @param name [Symbol] the strategy name to remove
+      def remove_strategy(name)
+        @strategies.delete(name)
+      end
+
+      # Authenticate a request using the specified or default strategy
+      # @param request [Hash] the request object containing headers, params, etc.
+      # @param strategy [Symbol] optional strategy override
+      # @return [Object, false] authentication result or false if failed
+      def authenticate(request, strategy: nil)
+        return { authenticated: true, user: nil } unless @enabled
+
+        strategy_name = strategy || @default_strategy
+        auth_strategy = @strategies[strategy_name]
+
+        return { authenticated: false, error: "Unknown strategy: #{strategy_name}" } unless auth_strategy
+
+        begin
+          result = auth_strategy.authenticate(request)
+          if result
+            { authenticated: true, user: result }
+          else
+            { authenticated: false, error: "Authentication failed" }
+          end
+        rescue StandardError => e
+          { authenticated: false, error: "Authentication error: #{e.message}" }
+        end
+      end
+
+      # Check if authentication is required
+      # @return [Boolean] true if authentication is enabled
+      def required?
+        @enabled
+      end
+
+      # Get list of available strategies
+      # @return [Array<Symbol>] array of strategy names
+      def available_strategies
+        @strategies.keys
+      end
+    end
+  end
+end