brainzlab 0.1.0 → 0.1.2

data/lib/brainzlab/utilities/log_formatter.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Utilities
+    # Beautiful log formatter for Rails development
+    # Provides colorized, structured output with request timing
+    #
+    # @example Usage in Rails
+    #   # config/environments/development.rb
+    #   config.log_formatter = BrainzLab::Utilities::LogFormatter.new
+    #
+    #   # Or use the Rails integration
+    #   BrainzLab::Utilities::LogFormatter.install!
+    #
+    class LogFormatter < ::Logger::Formatter
+      COLORS = {
+        debug: "\e[36m",    # Cyan
+        info: "\e[32m",     # Green
+        warn: "\e[33m",     # Yellow
+        error: "\e[31m",    # Red
+        fatal: "\e[35m",    # Magenta
+        reset: "\e[0m",
+        dim: "\e[2m",
+        bold: "\e[1m",
+        blue: "\e[34m",
+        gray: "\e[90m"
+      }.freeze
+
+      SEVERITY_ICONS = {
+        "DEBUG" => "🔍",
+        "INFO" => "ℹ️ ",
+        "WARN" => "⚠️ ",
+        "ERROR" => "❌",
+        "FATAL" => "💀"
+      }.freeze
+
+      HTTP_METHODS = {
+        "GET" => "\e[32m",     # Green
+        "POST" => "\e[33m",    # Yellow
+        "PUT" => "\e[34m",     # Blue
+        "PATCH" => "\e[34m",   # Blue
+        "DELETE" => "\e[31m",  # Red
+        "HEAD" => "\e[36m",    # Cyan
+        "OPTIONS" => "\e[36m"  # Cyan
+      }.freeze
+
+      def initialize(colorize: nil, show_timestamp: true, show_severity: true, compact: false)
+        super()
+        @colorize = colorize.nil? ? $stdout.tty? : colorize
+        @show_timestamp = show_timestamp
+        @show_severity = show_severity
+        @compact = compact
+      end
+
+      def call(severity, timestamp, progname, msg)
+        return "" if msg.nil? || msg.to_s.strip.empty?
+
+        message = format_message(msg)
+        return "" if skip_message?(message)
+
+        formatted = build_output(severity, timestamp, progname, message)
+        "#{formatted}\n"
+      end
+
+      # Install as Rails logger formatter
+      def self.install!
+        return unless defined?(Rails)
+
+        Rails.application.configure do
+          config.log_formatter = BrainzLab::Utilities::LogFormatter.new(
+            colorize: BrainzLab.configuration.log_formatter_colors,
+            compact: BrainzLab.configuration.log_formatter_compact_assets
+          )
+        end
+
+        # Also hook into ActiveSupport::TaggedLogging if present
+        if defined?(ActiveSupport::TaggedLogging) && Rails.logger.respond_to?(:formatter=)
+          Rails.logger.formatter = new
+        end
+      end
+
+      private
+
+      def format_message(msg)
+        case msg
+        when String
+          msg
+        when Exception
+          "#{msg.class}: #{msg.message}\n#{msg.backtrace&.first(10)&.join("\n")}"
+        else
+          msg.inspect
+        end
+      end
+
+      def skip_message?(message)
+        return false unless BrainzLab.configuration.log_formatter_hide_assets
+
+        # Skip asset pipeline noise
+        message.include?("/assets/") ||
+          message.include?("Asset pipeline") ||
+          message.match?(/Started GET "\/assets\//)
+      end
+
+      def build_output(severity, timestamp, progname, message)
+        parts = []
+
+        if @show_timestamp
+          ts = colorize(timestamp.strftime("%H:%M:%S.%L"), :gray)
+          parts << ts
+        end
+
+        if @show_severity
+          sev = format_severity(severity)
+          parts << sev
+        end
+
+        parts << format_content(message, severity)
+
+        parts.join(" ")
+      end
+
+      def format_severity(severity)
+        icon = SEVERITY_ICONS[severity] || ""
+        text = severity.ljust(5)
+
+        if @colorize
+          color = severity_color(severity)
+          "#{icon}#{color}#{text}#{COLORS[:reset]}"
+        else
+          "#{icon}[#{text}]"
+        end
+      end
+
+      def severity_color(severity)
+        case severity
+        when "DEBUG" then COLORS[:debug]
+        when "INFO" then COLORS[:info]
+        when "WARN" then COLORS[:warn]
+        when "ERROR" then COLORS[:error]
+        when "FATAL" then COLORS[:fatal]
+        else COLORS[:reset]
+        end
+      end
+
+      def format_content(message, severity)
+        # Handle Rails request log patterns
+        if (request_match = message.match(/Started (GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) "([^"]+)"/))
+          format_request_started(request_match[1], request_match[2])
+        elsif (completed_match = message.match(/Completed (\d+) .+ in (\d+(?:\.\d+)?)ms/))
+          format_request_completed(completed_match[1].to_i, completed_match[2].to_f)
+        elsif message.include?("Processing by")
+          format_processing(message)
+        elsif message.include?("Parameters:")
+          format_parameters(message)
+        elsif message.include?("Rendering") || message.include?("Rendered")
+          format_rendering(message)
+        elsif severity == "ERROR" || severity == "FATAL"
+          format_error(message)
+        else
+          message
+        end
+      end
+
+      def format_request_started(method, path)
+        method_color = HTTP_METHODS[method] || COLORS[:reset]
+
+        if @colorize
+          "#{COLORS[:bold]}→#{COLORS[:reset]} #{method_color}#{method}#{COLORS[:reset]} #{path}"
+        else
+          "→ #{method} #{path}"
+        end
+      end
+
+      def format_request_completed(status, duration)
+        status_color = case status
+                       when 200..299 then COLORS[:info]
+                       when 300..399 then COLORS[:blue]
+                       when 400..499 then COLORS[:warn]
+                       when 500..599 then COLORS[:error]
+                       else COLORS[:reset]
+                       end
+
+        duration_color = case duration
+                         when 0..100 then COLORS[:info]
+                         when 100..500 then COLORS[:warn]
+                         else COLORS[:error]
+                         end
+
+        if @colorize
+          "#{COLORS[:bold]}←#{COLORS[:reset]} #{status_color}#{status}#{COLORS[:reset]} #{duration_color}#{duration.round(1)}ms#{COLORS[:reset]}"
+        else
+          "← #{status} #{duration.round(1)}ms"
+        end
+      end
+
+      def format_processing(message)
+        if (match = message.match(/Processing by (\w+)#(\w+)/))
+          controller, action = match.captures
+          if @colorize
+            "  #{COLORS[:dim]}#{controller}##{action}#{COLORS[:reset]}"
+          else
+            "  #{controller}##{action}"
+          end
+        else
+          "  #{message}"
+        end
+      end
+
+      def format_parameters(message)
+        return message unless BrainzLab.configuration.log_formatter_show_params
+
+        if @colorize
+          "  #{COLORS[:dim]}#{message}#{COLORS[:reset]}"
+        else
+          "  #{message}"
+        end
+      end
+
+      def format_rendering(message)
+        if @compact
+          # Compact: just show the template name
+          if (match = message.match(/Render(?:ed|ing) ([^\s]+)/))
+            template = match[1].split("/").last
+            if @colorize
+              "    #{COLORS[:gray]}#{template}#{COLORS[:reset]}"
+            else
+              "    #{template}"
+            end
+          else
+            ""
+          end
+        else
+          if @colorize
+            "    #{COLORS[:dim]}#{message}#{COLORS[:reset]}"
+          else
+            "    #{message}"
+          end
+        end
+      end
+
+      def format_error(message)
+        if @colorize
+          "#{COLORS[:error]}#{message}#{COLORS[:reset]}"
+        else
+          message
+        end
+      end
+
+      def colorize(text, color)
+        return text unless @colorize
+
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+    end
+  end
+end

data/lib/brainzlab/utilities/rate_limiter.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Utilities
+    # Rate limiter with support for sliding window and token bucket algorithms
+    # Integrates with Flux for metrics tracking
+    #
+    # @example Basic usage
+    #   limiter = BrainzLab::Utilities::RateLimiter.new(
+    #     key: "api:user:123",
+    #     limit: 100,
+    #     window: 60  # seconds
+    #   )
+    #
+    #   if limiter.allow?
+    #     # proceed with request
+    #   else
+    #     # rate limited
+    #   end
+    #
+    # @example With block
+    #   BrainzLab::Utilities::RateLimiter.throttle("api:user:#{user.id}", limit: 100, window: 60) do
+    #     # this block runs only if not rate limited
+    #   end
+    #
+    class RateLimiter
+      attr_reader :key, :limit, :window, :remaining, :reset_at
+
+      def initialize(key:, limit:, window:, store: nil)
+        @key = key
+        @limit = limit
+        @window = window
+        @store = store || default_store
+        @remaining = limit
+        @reset_at = Time.now + window
+      end
+
+      # Check if request is allowed (doesn't consume a token)
+      def allowed?
+        count, reset = get_current_count
+        count < @limit
+      end
+
+      # Check and consume a token
+      def allow?
+        count, reset = increment
+        @remaining = [@limit - count, 0].max
+        @reset_at = reset
+
+        allowed = count <= @limit
+
+        # Track metrics
+        track_attempt(allowed)
+
+        allowed
+      end
+
+      # Alias for allow?
+      def throttle?
+        !allow?
+      end
+
+      # Get current usage info
+      def status
+        count, reset = get_current_count
+        {
+          key: @key,
+          limit: @limit,
+          remaining: [@limit - count, 0].max,
+          reset_at: reset,
+          used: count
+        }
+      end
+
+      # Reset the rate limit for this key
+      def reset!
+        @store.delete(@key)
+        @remaining = @limit
+        @reset_at = Time.now + @window
+      end
+
+      # Class method for quick throttling
+      def self.throttle(key, limit:, window:, store: nil)
+        limiter = new(key: key, limit: limit, window: window, store: store)
+
+        if limiter.allow?
+          yield if block_given?
+          true
+        else
+          false
+        end
+      end
+
+      # Check rate limit without incrementing
+      def self.allowed?(key, limit:, window:, store: nil)
+        limiter = new(key: key, limit: limit, window: window, store: store)
+        limiter.allowed?
+      end
+
+      private
+
+      def default_store
+        @default_store ||= MemoryStore.new
+      end
+
+      def get_current_count
+        bucket = current_bucket
+        data = @store.get(@key) || { buckets: {}, created_at: Time.now.to_i }
+
+        # Clean old buckets
+        cutoff = Time.now.to_i - @window
+        data[:buckets].delete_if { |k, _| k.to_i < cutoff }
+
+        count = data[:buckets].values.sum
+        reset = Time.at(Time.now.to_i + @window - (Time.now.to_i % @window))
+
+        [count, reset]
+      end
+
+      def increment
+        bucket = current_bucket
+        data = @store.get(@key) || { buckets: {}, created_at: Time.now.to_i }
+
+        # Clean old buckets
+        cutoff = Time.now.to_i - @window
+        data[:buckets].delete_if { |k, _| k.to_i < cutoff }
+
+        # Increment current bucket
+        data[:buckets][bucket] ||= 0
+        data[:buckets][bucket] += 1
+
+        # Store with TTL
+        @store.set(@key, data, ttl: @window * 2)
+
+        count = data[:buckets].values.sum
+        reset = Time.at(Time.now.to_i + @window - (Time.now.to_i % @window))
+
+        [count, reset]
+      end
+
+      def current_bucket
+        # Use 1-second buckets for sliding window
+        Time.now.to_i.to_s
+      end
+
+      def track_attempt(allowed)
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        if allowed
+          BrainzLab::Flux.increment("rate_limiter.allowed", tags: { key: sanitize_key(@key) })
+        else
+          BrainzLab::Flux.increment("rate_limiter.denied", tags: { key: sanitize_key(@key) })
+        end
+      end
+
+      def sanitize_key(key)
+        # Remove user-specific identifiers for aggregation
+        key.gsub(/:\d+/, ":*").gsub(/:[a-f0-9-]{36}/, ":*")
+      end
+
+      # Simple in-memory store (for development/single-instance)
+      class MemoryStore
+        def initialize
+          @data = {}
+          @mutex = Mutex.new
+        end
+
+        def get(key)
+          @mutex.synchronize do
+            entry = @data[key]
+            return nil unless entry
+            return nil if entry[:expires_at] && Time.now > entry[:expires_at]
+
+            entry[:value]
+          end
+        end
+
+        def set(key, value, ttl: nil)
+          @mutex.synchronize do
+            @data[key] = {
+              value: value,
+              expires_at: ttl ? Time.now + ttl : nil
+            }
+          end
+        end
+
+        def delete(key)
+          @mutex.synchronize do
+            @data.delete(key)
+          end
+        end
+
+        def clear!
+          @mutex.synchronize do
+            @data.clear
+          end
+        end
+      end
+
+      # Redis store adapter
+      class RedisStore
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def get(key)
+          data = @redis.get("brainzlab:ratelimit:#{key}")
+          return nil unless data
+
+          JSON.parse(data, symbolize_names: true)
+        rescue StandardError
+          nil
+        end
+
+        def set(key, value, ttl: nil)
+          full_key = "brainzlab:ratelimit:#{key}"
+          if ttl
+            @redis.setex(full_key, ttl, value.to_json)
+          else
+            @redis.set(full_key, value.to_json)
+          end
+        end
+
+        def delete(key)
+          @redis.del("brainzlab:ratelimit:#{key}")
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/utilities.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "utilities/rate_limiter"
+require_relative "utilities/circuit_breaker"
+require_relative "utilities/health_check"
+require_relative "utilities/log_formatter"
+
+module BrainzLab
+  module Utilities
+    # All utilities are auto-loaded from their respective files
+    # Access them via:
+    #   BrainzLab::Utilities::RateLimiter
+    #   BrainzLab::Utilities::CircuitBreaker
+    #   BrainzLab::Utilities::HealthCheck
+    #   BrainzLab::Utilities::LogFormatter
+  end
+end

data/lib/brainzlab/vault/cache.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Vault
+    class Cache
+      def initialize(ttl = 300)
+        @ttl = ttl
+        @store = {}
+        @mutex = Mutex.new
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          entry = @store[key]
+          return nil unless entry
+          return nil if expired?(entry)
+
+          entry[:value]
+        end
+      end
+
+      def set(key, value)
+        @mutex.synchronize do
+          @store[key] = {
+            value: value,
+            expires_at: Time.now + @ttl
+          }
+        end
+        value
+      end
+
+      def has?(key)
+        @mutex.synchronize do
+          entry = @store[key]
+          return false unless entry
+          return false if expired?(entry)
+
+          true
+        end
+      end
+
+      def delete(key)
+        @mutex.synchronize do
+          @store.delete(key)
+        end
+      end
+
+      def delete_pattern(pattern)
+        @mutex.synchronize do
+          regex = Regexp.new(pattern.gsub("*", ".*"))
+          @store.delete_if { |k, _| k.match?(regex) }
+        end
+      end
+
+      def clear!
+        @mutex.synchronize do
+          @store.clear
+        end
+      end
+
+      def size
+        @mutex.synchronize do
+          cleanup_expired!
+          @store.size
+        end
+      end
+
+      private
+
+      def expired?(entry)
+        entry[:expires_at] < Time.now
+      end
+
+      def cleanup_expired!
+        now = Time.now
+        @store.delete_if { |_, entry| entry[:expires_at] < now }
+      end
+    end
+  end
+end