fast_exists 1.0.0

data/lib/fast_exists/intelligence/report/builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module FastExists
+  module Intelligence
+    module Report
+      class Builder
+        def self.build(format: :console, output: nil, include: nil, compare: nil)
+          data = FastExists::Intelligence::DataModel.new
+          data.health = FastExists::Intelligence::Health.check
+          data.analysis = FastExists::Intelligence::Analyzer.analyze
+          data.audit = FastExists::Intelligence::Auditor.audit
+          data.doctor = FastExists::Intelligence::Doctor.diagnose(format: :json)
+
+          comparison_data = load_comparison(compare) if compare
+
+          rendered_content = case format.to_sym
+                             when :json
+                               FastExists::Intelligence::Report::Json.render(data, comparison: comparison_data)
+                             when :yaml
+                               FastExists::Intelligence::Report::Yaml.render(data, comparison: comparison_data)
+                             when :markdown
+                               FastExists::Intelligence::Report::Markdown.render(data, comparison: comparison_data)
+                             when :html
+                               FastExists::Intelligence::Report::Html.render(data, comparison: comparison_data)
+                             when :csv
+                               FastExists::Intelligence::Report::Csv.render(data, comparison: comparison_data)
+                             when :pdf
+                               FastExists::Intelligence::Report::Pdf.render(data, comparison: comparison_data)
+                             else
+                               FastExists::Intelligence::Report::Console.render(data, comparison: comparison_data)
+                             end
+
+          if output
+            FileUtils.mkdir_p(File.dirname(output))
+            File.write(output, rendered_content)
+            puts "Report generated successfully at #{output}"
+          end
+
+          rendered_content
+        end
+
+        private
+
+        def self.load_comparison(file_path)
+          return nil unless file_path && File.exist?(file_path)
+          JSON.parse(File.read(file_path), symbolize_names: true) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/console.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FastExists
+  module Intelligence
+    module Report
+      class Console
+        def self.render(data, comparison: nil)
+          lines = []
+          lines << "=========================================================="
+          lines << "⚡ FAST_EXISTS PERFORMANCE & ARCHITECTURE REPORT"
+          lines << "=========================================================="
+          lines << "Timestamp: #{data.timestamp}"
+          lines << "Environment: Ruby #{data.environment[:ruby_version]} | Rails #{data.environment[:rails_version]} | Adapter #{data.environment[:database_adapter]}"
+          lines << "Active Backend: #{data.environment[:backend]}"
+          lines << ""
+          lines << "1. OPERATIONAL HEALTH: #{data.health[:overall_status].to_s.upcase}"
+          data.health[:checks].each do |check|
+            mark = check[:status] == :pass ? "✓" : "⚠"
+            lines << "   #{mark} #{check[:name]}: #{check[:message]}"
+          end
+          lines << ""
+          lines << "2. ARCHITECTURAL AUDIT & GRADE"
+          lines << "   Audit Score: #{data.audit[:audit_score]}/100 (Grade: #{data.audit[:grade]})"
+          data.audit[:findings].each do |f|
+            lines << "   - [#{f[:severity].to_s.upcase}] #{f[:location]}: #{f[:problem]}"
+          end
+          lines << ""
+          lines << "3. RUNTIME STATISTICS"
+          lines << "   Queries Avoided:  #{data.stats[:queries_avoided]}"
+          lines << "   Database Lookups: #{data.stats[:database_lookups]}"
+          lines << "   Bloom Hits:       #{data.stats[:bloom_hits]}"
+          lines << "   Bloom Misses:     #{data.stats[:bloom_misses]}"
+          lines << "   Hit Ratio:        #{(data.stats[:hit_ratio] * 100).round(1)}%"
+          lines << "=========================================================="
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/csv.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module FastExists
+  module Intelligence
+    module Report
+      class Csv
+        def self.render(data, comparison: nil)
+          CSV.generate(headers: true) do |csv|
+            csv << ["Category", "Metric / Location", "Value / Message", "Status / Severity"]
+
+            csv << ["Environment", "Ruby Version", data.environment[:ruby_version], "info"]
+            csv << ["Environment", "Rails Version", data.environment[:rails_version], "info"]
+            csv << ["Environment", "Backend", data.environment[:backend], "info"]
+
+            csv << ["Health", "Overall Status", data.health[:overall_status], data.health[:overall_status]]
+            data.health[:checks].each do |c|
+              csv << ["Health Check", c[:name], c[:message], c[:status]]
+            end
+
+            csv << ["Stats", "Queries Avoided", data.stats[:queries_avoided], "info"]
+            csv << ["Stats", "Database Lookups", data.stats[:database_lookups], "info"]
+            csv << ["Stats", "Bloom Hits", data.stats[:bloom_hits], "info"]
+            csv << ["Stats", "False Positives", data.stats[:false_positives], "info"]
+            csv << ["Stats", "Hit Ratio", "#{(data.stats[:hit_ratio] * 100).round(1)}%", "info"]
+
+            csv << ["Audit", "Score", data.audit[:audit_score], data.audit[:grade]]
+            data.audit[:findings].each do |f|
+              csv << ["Audit Finding", f[:location], f[:problem], f[:severity]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/html.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module FastExists
+  module Intelligence
+    module Report
+      class Html
+        def self.render(data, comparison: nil)
+          hit_pct = (data.stats[:hit_ratio] * 100).round(1)
+          miss_pct = (data.stats[:miss_ratio] * 100).round(1)
+
+          <<-HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>FastExists Performance & Architecture Report</title>
+            <style>
+              :root {
+                --bg: #0f172a;
+                --card-bg: #1e293b;
+                --text: #f8fafc;
+                --text-muted: #94a3b8;
+                --accent: #38bdf8;
+                --border: #334155;
+                --pass: #22c55e;
+                --warn: #eab308;
+                --fail: #ef4444;
+              }
+              @media print {
+                body { background: #fff !important; color: #000 !important; }
+                .card { border: 1px solid #ccc !important; background: #fff !important; color: #000 !important; }
+              }
+              body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: var(--bg); color: var(--text); margin: 0; padding: 2.5rem; line-height: 1.5; }
+              .header { border-bottom: 1px solid var(--border); padding-bottom: 1.5rem; margin-bottom: 2rem; }
+              .title { font-size: 2.25rem; font-weight: 800; color: var(--accent); margin: 0 0 0.5rem 0; display: flex; align-items: center; gap: 0.5rem; }
+              .subtitle { color: var(--text-muted); font-size: 1rem; margin: 0; }
+              .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 1.5rem; margin-bottom: 2.5rem; }
+              .card { background: var(--card-bg); border-radius: 0.75rem; padding: 1.5rem; border: 1px solid var(--border); box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1); }
+              .card-title { color: var(--text-muted); font-size: 0.875rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 0.5rem; }
+              .card-val { font-size: 2.25rem; font-weight: 800; color: var(--accent); }
+              .badge { display: inline-block; padding: 0.25rem 0.75rem; border-radius: 9999px; font-weight: 700; font-size: 0.875rem; text-transform: uppercase; }
+              .badge-pass { background: rgba(34, 197, 94, 0.2); color: var(--pass); border: 1px solid var(--pass); }
+              .badge-warn { background: rgba(234, 179, 8, 0.2); color: var(--warn); border: 1px solid var(--warn); }
+              .badge-fail { background: rgba(239, 68, 68, 0.2); color: var(--fail); border: 1px solid var(--fail); }
+              section { margin-bottom: 3rem; }
+              h2 { font-size: 1.5rem; border-bottom: 1px solid var(--border); padding-bottom: 0.5rem; margin-bottom: 1.5rem; color: var(--text); }
+              table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
+              th, td { padding: 0.75rem 1rem; text-align: left; border-bottom: 1px solid var(--border); }
+              th { background: rgba(255,255,255,0.03); color: var(--text-muted); font-weight: 600; }
+              pre { background: #090d16; padding: 1rem; border-radius: 0.5rem; overflow-x: auto; color: #a5f3fc; border: 1px solid var(--border); font-family: monospace; }
+              .chart-bar { background: var(--border); height: 1.25rem; border-radius: 0.25rem; overflow: hidden; display: flex; margin-top: 0.5rem; }
+              .chart-fill-hit { background: var(--accent); height: 100%; width: #{hit_pct}%; }
+              .chart-fill-miss { background: #64748b; height: 100%; width: #{miss_pct}%; }
+            </style>
+          </head>
+          <body>
+            <div class="header">
+              <h1 class="title">⚡ FastExists Performance Intelligence Report</h1>
+              <p class="subtitle">Generated on #{data.timestamp} • Ruby #{data.environment[:ruby_version]} • Rails #{data.environment[:rails_version]} • Backend: <strong>#{data.environment[:backend]}</strong></p>
+            </div>
+
+            <div class="grid">
+              <div class="card">
+                <div class="card-title">Overall Health</div>
+                <div class="card-val"><span class="badge badge-#{data.health[:overall_status] == :healthy ? 'pass' : 'warn'}">#{data.health[:overall_status]}</span></div>
+              </div>
+              <div class="card">
+                <div class="card-title">Architecture Grade</div>
+                <div class="card-val">#{data.audit[:grade]} <span style="font-size:1.1rem; color:var(--text-muted)">(&nbsp;#{data.audit[:audit_score]}/100&nbsp;)</span></div>
+              </div>
+              <div class="card">
+                <div class="card-title">Queries Avoided</div>
+                <div class="card-val">#{data.stats[:queries_avoided]}</div>
+              </div>
+              <div class="card">
+                <div class="card-title">Database Lookups</div>
+                <div class="card-val">#{data.stats[:database_lookups]}</div>
+              </div>
+            </div>
+
+            <section>
+              <h2>📊 Query Distribution & Bloom Hit Ratio</h2>
+              <p>Hit Ratio: <strong>#{hit_pct}%</strong> | Miss Ratio: <strong>#{miss_pct}%</strong></p>
+              <div class="chart-bar">
+                <div class="chart-fill-hit" title="Hits: #{hit_pct}%"></div>
+                <div class="chart-fill-miss" title="Avoided: #{miss_pct}%"></div>
+              </div>
+            </section>
+
+            <section>
+              <h2>🩺 Operational Health Checks</h2>
+              <table>
+                <thead>
+                  <tr><th>Check Name</th><th>Status</th><th>Message</th></tr>
+                </thead>
+                <tbody>
+                  #{data.health[:checks].map { |c| "<tr><td><strong>#{c[:name]}</strong></td><td><span class=\"badge badge-#{c[:status] == :pass ? 'pass' : 'warn'}\">#{c[:status]}</span></td><td>#{c[:message]}</td></tr>" }.join("\n")}
+                </tbody>
+              </table>
+            </section>
+
+            <section>
+              <h2>🔍 Architectural Audit Findings</h2>
+              #{data.audit[:findings].map { |f| "<div class=\"card\" style=\"margin-bottom:1rem;\"><div style=\"display:flex; justify-between; align-items:center;\"><strong>[#{f[:severity].to_s.upcase}] #{f[:location]}</strong></div><p style=\"color:var(--text-muted)\">#{f[:problem]}</p><p><strong>Recommendation:</strong> #{f[:recommendation]}</p></div>" }.join("\n")}
+            </section>
+          </body>
+          </html>
+          HTML
+        end
+
+        def self.render_doctor(recs)
+          render(FastExists::Intelligence::DataModel.new)
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FastExists
+  module Intelligence
+    module Report
+      class Json
+        def self.render(data, comparison: nil)
+          payload = data.to_h
+          payload[:comparison] = comparison if comparison
+          JSON.pretty_generate(payload)
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/markdown.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module FastExists
+  module Intelligence
+    module Report
+      class Markdown
+        def self.render(data, comparison: nil)
+          lines = []
+          lines << "# ⚡ FastExists Performance & Architecture Report"
+          lines << ""
+          lines << "> **Generated**: `#{data.timestamp}`  "
+          lines << "> **Environment**: Ruby #{data.environment[:ruby_version]} | Rails #{data.environment[:rails_version]} | DB: `#{data.environment[:database_adapter]}`  "
+          lines << "> **Active Backend**: `#{data.environment[:backend]}`"
+          lines << ""
+          lines << "## Executive Summary"
+          lines << "- **Health Status**: `#{data.health[:overall_status].to_s.upcase}`"
+          lines << "- **Architecture Grade**: **#{data.audit[:grade]}** (#{data.audit[:audit_score]}/100)"
+          lines << "- **Queries Avoided**: **#{data.stats[:queries_avoided]}**"
+          lines << "- **Database Lookups**: #{data.stats[:database_lookups]}"
+          lines << "- **Hit Ratio**: #{(data.stats[:hit_ratio] * 100).round(1)}%"
+          lines << ""
+          lines << "## Health Check Findings"
+          data.health[:checks].each do |check|
+            badge = check[:status] == :pass ? "✅" : "⚠️"
+            lines << "- #{badge} **#{check[:name]}**: #{check[:message]}"
+          end
+          lines << ""
+          lines << "## Audit & Optimizations"
+          data.audit[:findings].each do |f|
+            lines << "### [#{f[:severity].to_s.upcase}] #{f[:location]}"
+            lines << "- **Problem**: #{f[:problem]}"
+            lines << "- **Recommendation**: #{f[:recommendation]}"
+            lines << "- **Impact**: #{f[:estimated_impact]}"
+            lines << ""
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/pdf.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FastExists
+  module Intelligence
+    module Report
+      class Pdf
+        def self.render(data, comparison: nil)
+          # Formats executive PDF-compatible markdown/text report
+          lines = []
+          lines << "% FAST_EXISTS PERFORMANCE & ARCHITECTURE REPORT"
+          lines << "% Executive Summary"
+          lines << "% Date: #{data.timestamp}"
+          lines << ""
+          lines << "================================================================================"
+          lines << "OVERALL OPERATIONAL HEALTH: #{data.health[:overall_status].to_s.upcase}"
+          lines << "ARCHITECTURAL GRADE: #{data.audit[:grade]} (Score: #{data.audit[:audit_score]}/100)"
+          lines << "QUERIES AVOIDED BY BLOOM FILTERS: #{data.stats[:queries_avoided]}"
+          lines << "================================================================================"
+          lines << ""
+          lines << "1. APPLICATION & ENVIRONMENT"
+          lines << "   - Ruby Version: #{data.environment[:ruby_version]}"
+          lines << "   - Rails Version: #{data.environment[:rails_version]}"
+          lines << "   - DB Adapter: #{data.environment[:database_adapter]}"
+          lines << "   - Backend Storage: #{data.environment[:backend]}"
+          lines << ""
+          lines << "2. HEALTH DIAGNOSTICS"
+          data.health[:checks].each do |c|
+            lines << "   - [#{c[:status].to_s.upcase}] #{c[:name]}: #{c[:message]}"
+          end
+          lines << ""
+          lines << "3. AUDIT & DOCTOR RECOMMENDATIONS"
+          data.audit[:findings].each do |f|
+            lines << "   * Location: #{f[:location]}"
+            lines << "     Severity: #{f[:severity].to_s.upcase}"
+            lines << "     Problem: #{f[:problem]}"
+            lines << "     Recommendation: #{f[:recommendation]}"
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/report/yaml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module FastExists
+  module Intelligence
+    module Report
+      class Yaml
+        def self.render(data, comparison: nil)
+          payload = data.to_h
+          payload[:comparison] = comparison if comparison
+          payload.transform_keys(&:to_s).to_yaml
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/intelligence/stats.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module FastExists
+  module Intelligence
+    class Stats
+      def self.render(format: :console)
+        raw_stats = FastExists.stats.merge(
+          active_backend: FastExists.configuration.backend,
+          uptime_seconds: (FastExists.uptime rescue 0),
+          sync_status: FastExists.configuration.auto_sync ? :active : :disabled
+        )
+
+        case format.to_sym
+        when :json
+          JSON.pretty_generate(raw_stats)
+        when :yaml
+          raw_stats.transform_keys(&:to_s).to_yaml
+        when :markdown
+          to_markdown(raw_stats)
+        else
+          to_console(raw_stats)
+        end
+      end
+
+      private
+
+      def self.to_console(s)
+        <<~CONSOLE
+          ==================================================
+          ⚡ FastExists Runtime Statistics
+          ==================================================
+          Active Backend:            #{s[:active_backend]}
+          Memory Usage:             #{s[:memory_usage] || 'N/A'}
+          Capacity:                 #{s[:capacity] || 'N/A'}
+          Occupancy:                #{s[:occupancy] || 'N/A'}
+          Bit Array Size:           #{s[:bit_size] || 'N/A'}
+          Hash Count:               #{s[:hash_count] || 'N/A'}
+          Inserted Elements:        #{s[:inserted_items] || 0}
+          Expected Elements:        #{s[:expected_elements] || 0}
+          Est. False Positive Rate: #{s[:estimated_false_positive_rate] || 0.0}%
+          Actual False Positives:   #{s[:false_positives]}
+          Bloom Hits:               #{s[:bloom_hits]}
+          Bloom Misses:             #{s[:bloom_misses]}
+          Queries Avoided:          #{s[:queries_avoided]}
+          Database Lookups:         #{s[:database_lookups]}
+          Hit Ratio:                #{(s[:hit_ratio] * 100).round(2)}%
+          Miss Ratio:               #{(s[:miss_ratio] * 100).round(2)}%
+          Synchronization Status:   #{s[:sync_status]}
+          ==================================================
+        CONSOLE
+      end
+
+      def self.to_markdown(s)
+        <<~MARKDOWN
+          # ⚡ FastExists Runtime Statistics
+
+          | Metric | Value |
+          |:---|:---|
+          | **Active Backend** | `#{s[:active_backend]}` |
+          | **Capacity** | #{s[:capacity] || 'N/A'} |
+          | **Inserted Elements** | #{s[:inserted_items] || 0} |
+          | **Queries Avoided** | **#{s[:queries_avoided]}** |
+          | **Database Lookups** | #{s[:database_lookups]} |
+          | **Bloom Hits** | #{s[:bloom_hits]} |
+          | **Bloom Misses** | #{s[:bloom_misses]} |
+          | **False Positives** | #{s[:false_positives]} |
+          | **Hit Ratio** | #{(s[:hit_ratio] * 100).round(2)}% |
+          | **Miss Ratio** | #{(s[:miss_ratio] * 100).round(2)}% |
+          | **Est. FP Rate** | #{s[:estimated_false_positive_rate] || 0.0}% |
+          | **Sync Status** | `#{s[:sync_status]}` |
+        MARKDOWN
+      end
+    end
+  end
+end

data/lib/fast_exists/multi_tenancy/resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FastExists
+  module MultiTenancy
+    class Resolver
+      def self.resolve(namespace_spec, record_or_context = nil)
+        case namespace_spec
+        when Proc
+          namespace_spec.call(record_or_context).to_s
+        when Symbol
+          if record_or_context && record_or_context.respond_to?(namespace_spec)
+            record_or_context.send(namespace_spec).to_s
+          else
+            namespace_spec.to_s
+          end
+        when String
+          namespace_spec
+        else
+          "default"
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/multi_tenant/allocator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FastExists
+  module MultiTenant
+    class Allocator
+      attr_reader :strategy
+
+      def initialize(strategy_type = FastExists.configuration.tenant_strategy, options = {})
+        @strategy_type = strategy_type.to_sym
+        @strategy = build_strategy(@strategy_type, options)
+      end
+
+      def add(tenant_id, attribute, value)
+        @strategy.add(tenant_id, attribute, value)
+      end
+
+      def contains?(tenant_id, attribute, value)
+        @strategy.contains?(tenant_id, attribute, value)
+      end
+
+      def stats
+        @strategy.stats.merge(strategy_type: @strategy_type)
+      end
+
+      private
+
+      def build_strategy(type, options)
+        case type
+        when :global
+          FastExists::MultiTenant::Strategies::GlobalStrategy.new(options)
+        when :per_tenant
+          FastExists::MultiTenant::Strategies::PerTenantStrategy.new(options)
+        when :shared
+          FastExists::MultiTenant::Strategies::SharedStrategy.new(options)
+        when :adaptive
+          FastExists::MultiTenant::Strategies::AdaptiveStrategy.new(options)
+        else
+          raise UnsupportedBackendError, "Unknown tenant strategy: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/fast_exists/multi_tenant/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "key_layout"
+require_relative "pool"
+require_relative "strategies/base_strategy"
+require_relative "strategies/global_strategy"
+require_relative "strategies/per_tenant_strategy"
+require_relative "strategies/shared_strategy"
+require_relative "strategies/adaptive_strategy"
+require_relative "allocator"
+require_relative "recommendation_engine"
+
+module FastExists
+  module MultiTenant
+    class << self
+      def allocator
+        @allocator ||= FastExists::MultiTenant::Allocator.new
+      end
+
+      def reset!
+        @allocator = nil
+      end
+    end
+  end
+end

data/lib/fast_exists/multi_tenant/key_layout.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FastExists
+  module MultiTenant
+    class KeyLayout
+      def self.global_key(prefix = FastExists.configuration.key_prefix)
+        "#{prefix}:global"
+      end
+
+      def self.pool_key(pool_name, prefix = FastExists.configuration.key_prefix)
+        "#{prefix}:pool:#{pool_name}"
+      end
+
+      def self.tenant_key(tenant_id, prefix = FastExists.configuration.key_prefix)
+        "#{prefix}:tenant:#{tenant_id}"
+      end
+    end
+  end
+end

data/lib/fast_exists/multi_tenant/pool.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module FastExists
+  module MultiTenant
+    class Pool
+      attr_reader :name, :expected_elements, :false_positive_rate, :backend
+
+      def initialize(name:, expected_elements:, false_positive_rate: 0.001, backend_type: nil)
+        @name = name
+        @expected_elements = expected_elements
+        @false_positive_rate = false_positive_rate
+        @backend_type = backend_type || FastExists.configuration.backend
+        @key = FastExists::MultiTenant::KeyLayout.pool_key(name)
+
+        @backend = FastExists.backends.fetch(
+          @backend_type,
+          namespace: "pool:#{name}",
+          expected_elements: expected_elements,
+          false_positive_rate: false_positive_rate
+        )
+      end
+
+      def add(tenant_id, attribute, value)
+        composite_key = "#{tenant_id}:#{attribute}:#{value}"
+        @backend.add(composite_key)
+      end
+
+      def contains?(tenant_id, attribute, value)
+        composite_key = "#{tenant_id}:#{attribute}:#{value}"
+        @backend.contains?(composite_key)
+      end
+
+      def clear
+        @backend.clear
+      end
+
+      def stats
+        @backend.stats.merge(pool_name: @name, pool_key: @key)
+      end
+    end
+  end
+end