vector_mcp 0.3.1 → 0.3.3

data/lib/vector_mcp/logging/configuration.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module VectorMCP
-  module Logging
-    class Configuration
-      DEFAULT_CONFIG = {
-        level: "INFO",
-        format: "text",
-        output: "console",
-        components: {},
-        console: {
-          colorize: true,
-          include_timestamp: true,
-          include_thread: false
-        },
-        file: {
-          path: nil,
-          rotation: "daily",
-          max_size: "100MB",
-          max_files: 7
-        }
-      }.freeze
-
-      attr_reader :config
-
-      def initialize(config = {})
-        @config = deep_merge(DEFAULT_CONFIG, normalize_config(config))
-        validate_config!
-      end
-
-      def self.from_file(path)
-        config = YAML.load_file(path)
-        new(config["logging"] || config)
-      rescue StandardError => e
-        raise ConfigurationError, "Failed to load configuration from #{path}: #{e.message}"
-      end
-
-      def self.from_env
-        config = {}
-
-        config[:level] = ENV["VECTORMCP_LOG_LEVEL"] if ENV["VECTORMCP_LOG_LEVEL"]
-        config[:format] = ENV["VECTORMCP_LOG_FORMAT"] if ENV["VECTORMCP_LOG_FORMAT"]
-        config[:output] = ENV["VECTORMCP_LOG_OUTPUT"] if ENV["VECTORMCP_LOG_OUTPUT"]
-
-        config[:file] = { path: ENV["VECTORMCP_LOG_FILE_PATH"] } if ENV["VECTORMCP_LOG_FILE_PATH"]
-
-        new(config)
-      end
-
-      def level_for(component)
-        component_level = @config[:components][component.to_s]
-        level_value = component_level || @config[:level]
-        Logging.level_value(level_value)
-      end
-
-      def set_component_level(component, level)
-        @config[:components][component.to_s] = if level.is_a?(Integer)
-                                                 Logging.level_name(level)
-                                               else
-                                                 level.to_s.upcase
-                                               end
-      end
-
-      def component_config(component_name)
-        @config[:components][component_name.to_s] || {}
-      end
-
-      def console_config
-        @config[:console]
-      end
-
-      def file_config
-        @config[:file]
-      end
-
-      def format
-        @config[:format]
-      end
-
-      def output
-        @config[:output]
-      end
-
-      def configure(&)
-        instance_eval(&) if block_given?
-        validate_config!
-      end
-
-      def level(new_level)
-        @config[:level] = new_level.to_s.upcase
-      end
-
-      def component(name, level:)
-        @config[:components][name.to_s] = level.to_s.upcase
-      end
-
-      def console(options = {})
-        @config[:console].merge!(options)
-      end
-
-      def file(options = {})
-        @config[:file].merge!(options)
-      end
-
-      def to_h
-        @config.dup
-      end
-
-      private
-
-      def normalize_config(config)
-        case config
-        when Hash
-          config.transform_keys(&:to_sym)
-        when String
-          { level: config }
-        else
-          {}
-        end
-      end
-
-      def deep_merge(hash1, hash2)
-        result = hash1.dup
-        hash2.each do |key, value|
-          result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
-                          deep_merge(result[key], value)
-                        else
-                          value
-                        end
-        end
-        result
-      end
-
-      def validate_config!
-        validate_level!(@config[:level])
-        @config[:components].each_value do |level|
-          validate_level!(level)
-        end
-
-        raise ConfigurationError, "Invalid format: #{@config[:format]}" unless %w[text json].include?(@config[:format])
-
-        return if %w[console file both].include?(@config[:output])
-
-        raise ConfigurationError, "Invalid output: #{@config[:output]}"
-      end
-
-      def validate_level!(level)
-        return if Logging::LEVELS.key?(level.to_s.upcase.to_sym)
-
-        raise ConfigurationError, "Invalid log level: #{level}"
-      end
-    end
-  end
-end

data/lib/vector_mcp/logging/constants.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module VectorMCP
-  module Logging
-    module Constants
-      # JSON serialization limits
-      MAX_SERIALIZATION_DEPTH = 5
-      MAX_ARRAY_SERIALIZATION_DEPTH = 3
-      MAX_ARRAY_ELEMENTS_TO_SERIALIZE = 10
-
-      # Text formatting limits
-      DEFAULT_MAX_MESSAGE_LENGTH = 1000
-      DEFAULT_COMPONENT_WIDTH = 20
-      DEFAULT_LEVEL_WIDTH = 8
-      TRUNCATION_SUFFIX_LENGTH = 4 # for "..."
-
-      # ISO timestamp precision
-      TIMESTAMP_PRECISION = 3 # milliseconds
-    end
-  end
-end

data/lib/vector_mcp/logging/core.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-
-module VectorMCP
-  module Logging
-    class Core
-      attr_reader :configuration, :components, :outputs
-
-      def initialize(configuration = nil)
-        @configuration = configuration || Configuration.new
-        @components = {}
-        @outputs = []
-        @mutex = Mutex.new
-        @legacy_logger = nil
-
-        setup_default_output
-      end
-
-      def logger_for(component_name)
-        @mutex.synchronize do
-          @components[component_name] ||= Component.new(
-            component_name,
-            self,
-            @configuration.component_config(component_name)
-          )
-        end
-      end
-
-      def legacy_logger
-        @legacy_logger ||= LegacyAdapter.new(self)
-      end
-
-      def log(level, component, message, context = {})
-        return unless should_log?(level, component)
-
-        log_entry = Logging::LogEntry.new({
-                                            timestamp: Time.now,
-                                            level: level,
-                                            component: component,
-                                            message: message,
-                                            context: context,
-                                            thread_id: Thread.current.object_id
-                                          })
-
-        @outputs.each do |output|
-          output.write(log_entry)
-        rescue StandardError => e
-          warn "Failed to write to output #{output.class}: #{e.message}"
-        end
-      end
-
-      def add_output(output)
-        @mutex.synchronize do
-          @outputs << output unless @outputs.include?(output)
-        end
-      end
-
-      def remove_output(output)
-        @mutex.synchronize do
-          @outputs.delete(output)
-        end
-      end
-
-      def configure(&)
-        @configuration.configure(&)
-        reconfigure_outputs
-      end
-
-      def shutdown
-        @outputs.each(&:close)
-        @outputs.clear
-      end
-
-      private
-
-      def should_log?(level, component)
-        min_level = @configuration.level_for(component)
-        level >= min_level
-      end
-
-      def setup_default_output
-        console_output = Outputs::Console.new(@configuration.console_config)
-        add_output(console_output)
-      end
-
-      def reconfigure_outputs
-        @outputs.each(&:reconfigure)
-      end
-    end
-
-    class LegacyAdapter
-      def initialize(core)
-        @core = core
-        @component = "legacy"
-        @progname = "VectorMCP"
-      end
-
-      def debug(message = nil, &)
-        log_with_block(Logging::LEVELS[:DEBUG], message, &)
-      end
-
-      def info(message = nil, &)
-        log_with_block(Logging::LEVELS[:INFO], message, &)
-      end
-
-      def warn(message = nil, &)
-        log_with_block(Logging::LEVELS[:WARN], message, &)
-      end
-
-      def error(message = nil, &)
-        log_with_block(Logging::LEVELS[:ERROR], message, &)
-      end
-
-      def fatal(message = nil, &)
-        log_with_block(Logging::LEVELS[:FATAL], message, &)
-      end
-
-      def level
-        @core.configuration.level_for(@component)
-      end
-
-      def level=(new_level)
-        @core.configuration.set_component_level(@component, new_level)
-      end
-
-      attr_accessor :progname
-
-      def add(severity, message = nil, progname = nil, &block)
-        actual_message = message || block&.call || progname
-        @core.log(severity, @component, actual_message)
-      end
-
-      # For backward compatibility with Logger interface checks
-      def is_a?(klass)
-        return true if klass == Logger
-
-        super
-      end
-
-      def kind_of?(klass)
-        return true if klass == Logger
-
-        super
-      end
-
-      # Simulate Logger's logdev for compatibility
-      def instance_variable_get(var_name)
-        if var_name == :@logdev
-          # Return a mock object that simulates Logger's logdev
-          MockLogdev.new
-        else
-          super
-        end
-      end
-
-      private
-
-      def log_with_block(level, message, &block)
-        if block_given?
-          return unless @core.configuration.level_for(@component) <= level
-
-          message = block.call
-        end
-        @core.log(level, @component, message)
-      end
-    end
-
-    class MockLogdev
-      def dev
-        $stderr
-      end
-    end
-  end
-end

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

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

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

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

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

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