vector_mcp 0.2.0 → 0.3.1

data/lib/vector_mcp/logging/core.rb

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

@@ -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