RubyGems - cache_stache - Versions diffs - 0.1.0 - Mend

cache_stache 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

checksums.yaml +7 -0
data/README.md +231 -0
data/app/assets/stylesheets/cache_stache/application.css +5 -0
data/app/assets/stylesheets/cache_stache/pico.css +4 -0
data/app/controllers/cache_stache/application_controller.rb +11 -0
data/app/controllers/cache_stache/dashboard_controller.rb +32 -0
data/app/helpers/cache_stache/application_helper.rb +37 -0
data/app/views/cache_stache/dashboard/index.html.erb +154 -0
data/app/views/cache_stache/dashboard/keyspace.html.erb +83 -0
data/app/views/layouts/cache_stache/application.html.erb +14 -0
data/config/routes.rb +6 -0
data/lib/cache_stache/cache_client.rb +202 -0
data/lib/cache_stache/configuration.rb +87 -0
data/lib/cache_stache/engine.rb +17 -0
data/lib/cache_stache/instrumentation.rb +142 -0
data/lib/cache_stache/keyspace.rb +28 -0
data/lib/cache_stache/rack_after_reply_middleware.rb +22 -0
data/lib/cache_stache/railtie.rb +30 -0
data/lib/cache_stache/stats_query.rb +89 -0
data/lib/cache_stache/version.rb +5 -0
data/lib/cache_stache/web.rb +69 -0
data/lib/cache_stache/window_options.rb +34 -0
data/lib/cache_stache.rb +37 -0
data/lib/generators/cache_stache/install_generator.rb +21 -0
data/lib/generators/cache_stache/templates/README +35 -0
data/lib/generators/cache_stache/templates/cache_stache.rb +43 -0
data/spec/cache_stache_helper.rb +148 -0
data/spec/dummy_app/Rakefile +5 -0
data/spec/dummy_app/app/assets/config/manifest.js +1 -0
data/spec/dummy_app/config/application.rb +31 -0
data/spec/dummy_app/config/boot.rb +3 -0
data/spec/dummy_app/config/environment.rb +5 -0
data/spec/dummy_app/config/routes.rb +7 -0
data/spec/integration/dashboard_controller_spec.rb +94 -0
data/spec/integration/full_cache_flow_spec.rb +202 -0
data/spec/integration/instrumentation_spec.rb +259 -0
data/spec/integration/rack_after_reply_spec.rb +47 -0
data/spec/integration/rake_tasks_spec.rb +17 -0
data/spec/spec_helper.rb +64 -0
data/spec/unit/cache_client_spec.rb +278 -0
data/spec/unit/configuration_spec.rb +209 -0
data/spec/unit/keyspace_spec.rb +93 -0
data/spec/unit/stats_query_spec.rb +367 -0
data/tasks/cache_stache.rake +74 -0
metadata +226 -0

data/app/views/cache_stache/dashboard/keyspace.html.erb ADDED Viewed

@@ -0,0 +1,83 @@
+<p><small><%= link_to "← Back to Dashboard", root_path(window: params[:window]) %></small></p>
+<div class="grid">
+  <div>
+    <%= form_with url: keyspace_path(@keyspace.name), method: :get, local: true do |f| %>
+      <label for="window">
+        Time Window:
+        <%= f.select :window, window_options, { selected: params[:window] || "1h" }, { onchange: "this.form.submit();" } %>
+      </label>
+    <% end %>
+  </div>
+  <div>
+    <small>Last updated: <%= Time.current.strftime("%Y-%m-%d %H:%M:%S %Z") %></small>
+  </div>
+</div>
+<article>
+    <header>
+      <h2><%= @keyspace.label %></h2>
+      <p><small>Pattern: <code><%= @keyspace.pattern.inspect %></code></small></p>
+    </header>
+    <div role="group">
+      <article>
+        <small>Hit Rate</small>
+        <h3><mark><%= number_to_percentage(@keyspace_stats[:hit_rate_percent], precision: 1) %></mark></h3>
+      </article>
+      <article>
+        <small>Total Operations</small>
+        <h3><%= number_with_delimiter(@keyspace_stats[:total_operations]) %></h3>
+      </article>
+      <article>
+        <small>Cache Hits</small>
+        <h3><%= number_with_delimiter(@keyspace_stats[:hits]) %></h3>
+      </article>
+      <article>
+        <small>Cache Misses</small>
+        <h3><%= number_with_delimiter(@keyspace_stats[:misses]) %></h3>
+      </article>
+    </div>
+    <footer>
+      <small>
+        Showing data for the last <%= current_window_label %>
+        (<%= @results[:bucket_count] %> buckets of <%= @config.bucket_seconds / 60 %> minutes each)
+      </small>
+    </footer>
+  </article>
+  <article>
+    <header>
+      <h2>Hit Rate Over Time</h2>
+    </header>
+    <% sparkline = sparkline_data(@results[:buckets], @keyspace.name) %>
+    <% if sparkline.any? %>
+      <figure>
+        <table>
+          <thead>
+            <tr>
+              <th>Time (<%= Time.current.strftime("%Z") %>)</th>
+              <th>Hit Rate</th>
+              <th>Operations</th>
+              <th style="width: 100px;"></th>
+            </tr>
+          </thead>
+          <tbody>
+            <% sparkline.each do |point| %>
+              <tr>
+                <td><%= Time.parse(point[:time]).strftime("%H:%M:%S") %></td>
+                <td><%= number_to_percentage(point[:hit_rate], precision: 1) %></td>
+                <td><%= number_with_delimiter(point[:operations]) %></td>
+                <td>
+                  <progress value="<%= point[:hit_rate] %>" max="100"><%= point[:hit_rate] %>%</progress>
+                </td>
+              </tr>
+            <% end %>
+          </tbody>
+        </table>
+      </figure>
+    <% else %>
+      <p><small>No data available for this time period.</small></p>
+    <% end %>
+  </article>

data/app/views/layouts/cache_stache/application.html.erb ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>CacheStache - Cache Hit Rate Insights</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <%= stylesheet_link_tag "cache_stache/pico", media: "all" %>
+  <%= stylesheet_link_tag "cache_stache/application", media: "all" %>
+</head>
+<body>
+  <main>
+    <%= yield %>
+  </main>
+</body>
+</html>

data/config/routes.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+CacheStache::Engine.routes.draw do
+  root to: "dashboard#index"
+  get "keyspaces/:name", to: "dashboard#keyspace", as: :keyspace
+end

data/lib/cache_stache/cache_client.rb ADDED Viewed

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+require "redis"
+require "connection_pool"
+module CacheStache
+  class CacheClient
+    # Lua script for atomic increment with expiry
+    INCR_AND_EXPIRE_SCRIPT = <<~LUA
+      local key = KEYS[1]
+      local expire_seconds = tonumber(ARGV[1])
+      local increments = cjson.decode(ARGV[2])
+      for field, value in pairs(increments) do
+        redis.call('HINCRBYFLOAT', key, field, value)
+      end
+      local ttl = redis.call('TTL', key)
+      if ttl == -1 or ttl < expire_seconds then
+        redis.call('EXPIRE', key, expire_seconds)
+      end
+      return redis.status_reply('OK')
+    LUA
+    def initialize(config = CacheStache.configuration)
+      @config = config
+      @pool = ConnectionPool.new(size: @config.redis_pool_size) do
+        Redis.new(url: @config.redis_url)
+      end
+    end
+    def increment_stats(bucket_ts, increments)
+      key = bucket_key(bucket_ts)
+      without_instrumentation do
+        @pool.with do |redis|
+          Rails.logger.debug { "CacheStache: Redis EVAL increment on #{key} with #{increments.size} fields" }
+          redis.eval(
+            INCR_AND_EXPIRE_SCRIPT,
+            keys: [key],
+            argv: [@config.retention_seconds, increments.to_json]
+          )
+        end
+      end
+    rescue => e
+      Rails.logger.error("CacheStache: Failed to increment stats: #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+    end
+    def fetch_buckets(from_ts, to_ts)
+      keys = bucket_keys_in_range(from_ts, to_ts)
+      return [] if keys.empty?
+      Rails.logger.debug { "CacheStache: Redis fetching #{keys.size} buckets from #{from_ts} to #{to_ts}" }
+      without_instrumentation do
+        @pool.with do |redis|
+          Rails.logger.debug { "CacheStache: Redis PIPELINE hgetall for #{keys.size} keys" }
+          pipeline_results = redis.pipelined do |pipe|
+            keys.each { |key| pipe.hgetall(key) }
+          end
+          keys.zip(pipeline_results).map do |key, data|
+            next unless data && !data.empty?
+            {
+              timestamp: extract_timestamp_from_key(key),
+              stats: data.transform_values(&:to_f)
+            }
+          end.compact
+        end
+      end
+    rescue => e
+      Rails.logger.error("CacheStache: Failed to fetch buckets: #{e.message}")
+      []
+    end
+    def store_config_metadata
+      key = "cache_stache:v1:#{@config.rails_env}:config"
+      metadata = {
+        bucket_seconds: @config.bucket_seconds,
+        retention_seconds: @config.retention_seconds,
+        updated_at: Time.current.to_i
+      }
+      without_instrumentation do
+        @pool.with do |redis|
+          # Use SETEX for atomic set-with-expiry (single command)
+          Rails.logger.debug { "CacheStache: Redis SETEX #{key} #{@config.retention_seconds}" }
+          redis.setex(key, @config.retention_seconds, metadata.to_json)
+        end
+      end
+    rescue => e
+      Rails.logger.error("CacheStache: Failed to store config metadata: #{e.message}")
+    end
+    def fetch_config_metadata
+      key = "cache_stache:v1:#{@config.rails_env}:config"
+      without_instrumentation do
+        @pool.with do |redis|
+          Rails.logger.debug { "CacheStache: Redis GET #{key}" }
+          data = redis.get(key)
+          data ? JSON.parse(data) : nil
+        end
+      end
+    rescue => e
+      Rails.logger.error("CacheStache: Failed to fetch config metadata: #{e.message}")
+      nil
+    end
+    def estimate_storage_size
+      # Calculate theoretical number of buckets
+      max_buckets = (@config.retention_seconds.to_f / @config.bucket_seconds).ceil
+      # Each bucket has:
+      # - overall:hits and overall:misses (2 fields)
+      # - keyspace_name:hits and keyspace_name:misses per keyspace (2 * num_keyspaces)
+      fields_per_bucket = 2 + (@config.keyspaces.size * 2)
+      # Estimate bytes per field:
+      # - Field name: ~20 bytes average (e.g., "search:hits", "profiles:misses")
+      # - Field value: ~8 bytes (float stored as string, e.g., "12345.0")
+      # - Redis hash overhead: ~24 bytes per field
+      bytes_per_field = 52
+      # Key overhead: "cache_stache:v1:environment:timestamp" ~45 bytes
+      # Plus Redis key overhead: ~96 bytes
+      key_overhead = 141
+      # Calculate total size per bucket
+      bytes_per_bucket = (fields_per_bucket * bytes_per_field) + key_overhead
+      # Total estimated size
+      total_bytes = max_buckets * bytes_per_bucket
+      # Add config metadata key size (~200 bytes)
+      total_bytes += 200
+      {
+        max_buckets: max_buckets,
+        fields_per_bucket: fields_per_bucket,
+        bytes_per_bucket: bytes_per_bucket,
+        total_bytes: total_bytes,
+        human_size: format_bytes(total_bytes)
+      }
+    rescue => e
+      Rails.logger.error("CacheStache: Failed to estimate storage size: #{e.message}")
+      {total_bytes: 0, human_size: "Unknown"}
+    end
+    private
+    def format_bytes(bytes)
+      if bytes < 1024
+        "#{bytes} B"
+      elsif bytes < 1024 * 1024
+        "#{(bytes / 1024.0).round(1)} KB"
+      elsif bytes < 1024 * 1024 * 1024
+        "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+      else
+        "#{(bytes / (1024.0 * 1024 * 1024)).round(2)} GB"
+      end
+    end
+    def bucket_key(timestamp)
+      "cache_stache:v1:#{@config.rails_env}:#{timestamp}"
+    end
+    def bucket_keys_in_range(from_ts, to_ts)
+      timestamps = []
+      current = align_to_bucket(from_ts)
+      to_aligned = align_to_bucket(to_ts)
+      while current <= to_aligned
+        timestamps << current
+        current += @config.bucket_seconds
+      end
+      # Limit to most recent max_buckets
+      if timestamps.size > @config.max_buckets
+        Rails.logger.warn("CacheStache: Truncating bucket range from #{timestamps.size} to #{@config.max_buckets} buckets (requested #{from_ts} to #{to_ts})")
+        timestamps = timestamps.last(@config.max_buckets)
+      end
+      timestamps.map { |ts| bucket_key(ts) }
+    end
+    def align_to_bucket(timestamp)
+      (timestamp.to_i / @config.bucket_seconds) * @config.bucket_seconds
+    end
+    def extract_timestamp_from_key(key)
+      key.split(":").last.to_i
+    end
+    def without_instrumentation(&block)
+      CacheStache::Instrumentation.without_instrumentation(&block)
+    end
+  end
+end

data/lib/cache_stache/configuration.rb ADDED Viewed

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require "digest/md5"
+require "active_support/core_ext/numeric/time"
+module CacheStache
+  class Configuration
+    attr_accessor :bucket_seconds, :retention_seconds, :sample_rate, :enabled,
+      :redis_url, :redis_pool_size, :use_rack_after_reply, :max_buckets
+    attr_reader :keyspaces
+    def initialize
+      @bucket_seconds = 5.minutes.to_i
+      @retention_seconds = 7.days.to_i
+      @sample_rate = 1.0
+      @enabled = rails_env != "test"
+      @use_rack_after_reply = false
+      @redis_url = ENV.fetch("CACHE_STACHE_REDIS_URL") { ENV.fetch("REDIS_URL", "redis://localhost:6379/0") }
+      @redis_pool_size = 5
+      @max_buckets = 288
+      @keyspaces = []
+      @keyspace_cache = {}
+    end
+    def keyspace(name, &block)
+      ks = Keyspace.new(name)
+      builder = KeyspaceBuilder.new(ks)
+      builder.instance_eval(&block) if block_given?
+      ks.validate!
+      raise Error, "Keyspace #{name} already defined" if @keyspaces.any? { |k| k.name == name }
+      @keyspaces << ks
+      ks
+    end
+    def matching_keyspaces(key)
+      # Simple memoization per key to avoid repeated block execution
+      cache_key = key_digest(key)
+      @keyspace_cache[cache_key] ||= @keyspaces.select { |ks| ks.match?(key) }
+    end
+    def validate!
+      raise Error, "bucket_seconds must be positive" unless bucket_seconds.to_i.positive?
+      raise Error, "retention_seconds must be positive" unless retention_seconds.to_i.positive?
+      raise Error, "redis_pool_size must be positive" unless redis_pool_size.to_i.positive?
+      raise Error, "redis_url must be configured" if redis_url.to_s.strip.empty?
+      raise Error, "sample_rate must be between 0 and 1" unless sample_rate&.between?(0, 1)
+      raise Error, "max_buckets must be positive" unless max_buckets.to_i.positive?
+      if retention_seconds % bucket_seconds != 0
+        Rails.logger.warn(
+          "CacheStache: retention_seconds (#{retention_seconds}) does not divide evenly " \
+          "by bucket_seconds (#{bucket_seconds}). This may result in partial bucket retention."
+        )
+      end
+      @keyspaces.each(&:validate!)
+    end
+    def rails_env
+      @rails_env ||= ENV.fetch("RAILS_ENV", "development")
+    end
+    private
+    def key_digest(key)
+      # Use last 4 chars of a simple hash as cache key
+      Digest::MD5.hexdigest(key.to_s)[-4..]
+    end
+    class KeyspaceBuilder
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+      def label(value)
+        @keyspace.label = value
+      end
+      def match(regex)
+        raise Error, "match requires a Regexp argument, got #{regex.class}" unless regex.is_a?(Regexp)
+        @keyspace.pattern = regex
+      end
+    end
+  end
+end

data/lib/cache_stache/engine.rb ADDED Viewed

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "pathname"
+require "rails/engine"
+module CacheStache
+  class Engine < ::Rails::Engine
+    isolate_namespace CacheStache
+    # Engine root is lib/cache_stache/
+    config.root = Pathname.new(File.expand_path("../..", __dir__))
+    initializer "cache_stache.assets.precompile" do |app|
+      app.config.assets.precompile += %w[cache_stache/pico.css cache_stache/application.css]
+    end
+  end
+end

data/lib/cache_stache/instrumentation.rb ADDED Viewed

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+module CacheStache
+  module Instrumentation
+    # Thread-local key to track when CacheStache is performing internal operations
+    INTERNAL_OPERATION_KEY = :cache_stache_internal_operation
+    AFTER_REPLY_QUEUE_KEY = :cache_stache_after_reply_queue
+    MAX_AFTER_REPLY_EVENTS = 1000
+    class << self
+      attr_reader :monitored_store_class
+      def reset!
+        @installed = false
+        @monitored_store_class = nil
+        @cache_client = nil
+      end
+      def install!
+        return unless CacheStache.configuration.enabled
+        return if @installed
+        # Store cache_client as a class instance variable
+        @cache_client = CacheClient.new
+        @cache_client.store_config_metadata
+        # Capture the Rails.cache store class name to filter events.
+        # Note: This filters by class name, not instance. If multiple stores
+        # use the same class (e.g., two RedisCacheStore instances), events
+        # from all of them will be tracked.
+        @monitored_store_class = Rails.cache.class.name
+        # Subscribe to cache read events only (hits and misses)
+        ActiveSupport::Notifications.subscribe("cache_read.active_support", self)
+        @installed = true
+        Rails.logger.info("CacheStache: Instrumentation installed for #{@monitored_store_class}")
+      end
+      # Execute a block while marking it as an internal CacheStache operation.
+      # Cache operations inside this block will be ignored by instrumentation.
+      def without_instrumentation
+        previous_value = Thread.current[INTERNAL_OPERATION_KEY]
+        Thread.current[INTERNAL_OPERATION_KEY] = true
+        yield
+      ensure
+        Thread.current[INTERNAL_OPERATION_KEY] = previous_value
+      end
+      # Returns true if we're currently inside an internal CacheStache operation
+      def internal_operation?
+        Thread.current[INTERNAL_OPERATION_KEY] == true
+      end
+      def call(_name, _start, _finish, _id, payload)
+        # Skip if this is an internal CacheStache operation
+        return if internal_operation?
+        # Only track events from Rails.cache, not other ActiveSupport::Cache instances
+        return unless payload[:store] == @monitored_store_class
+        key = payload[:key] || payload[:name]
+        return unless key
+        # Belt-and-suspenders: also skip by key prefix in case thread-local wasn't set
+        return if key.to_s.start_with?("cache_stache:")
+        # Skip event based on sample_rate (e.g., 0.5 means record 50% of events)
+        sample_rate = CacheStache.configuration.sample_rate
+        return if sample_rate < 1.0 && rand >= sample_rate
+        # Record hit or miss
+        bucket_ts = (Time.current.to_i / CacheStache.configuration.bucket_seconds) * CacheStache.configuration.bucket_seconds
+        hit = payload[:hit]
+        increments = {
+          "overall:hits" => hit ? 1 : 0,
+          "overall:misses" => hit ? 0 : 1
+        }
+        # Add keyspace increments
+        matching_keyspaces = CacheStache.configuration.matching_keyspaces(key)
+        matching_keyspaces.each do |keyspace|
+          increments["#{keyspace.name}:hits"] = hit ? 1 : 0
+          increments["#{keyspace.name}:misses"] = hit ? 0 : 1
+        end
+        # Filter out zero-valued fields to reduce write amplification
+        increments.reject! { |_k, v| v == 0 }
+        if should_defer_instrumentation?
+          enqueue_after_reply_event(bucket_ts, increments)
+        else
+          @cache_client.increment_stats(bucket_ts, increments)
+        end
+      rescue => e
+        Rails.logger.error("CacheStache instrumentation error: #{e.class}: #{e.message}")
+        Rails.logger.error(e.backtrace.first(5).join("\n"))
+      end
+      def flush_after_reply_queue!
+        return unless @cache_client
+        queue = Thread.current[AFTER_REPLY_QUEUE_KEY]
+        return unless queue.is_a?(Array) && !queue.empty?
+        max = MAX_AFTER_REPLY_EVENTS
+        dropped = [queue.size - max, 0].max
+        events = queue.shift([queue.size, max].min)
+        queue.clear
+        Rails.logger.warn("CacheStache: Dropped #{dropped} after-reply events") if dropped.positive?
+        combined = {}
+        events.each do |(bucket_ts, increments)|
+          combined[bucket_ts] ||= Hash.new(0)
+          increments.each do |field, value|
+            combined[bucket_ts][field] += value
+          end
+        end
+        combined.each do |bucket_ts, increments|
+          # Filter out zero-valued fields to reduce write amplification
+          increments.reject! { |_k, v| v == 0 }
+          @cache_client.increment_stats(bucket_ts, increments)
+        end
+      rescue => e
+        Rails.logger.error("CacheStache after-reply flush error: #{e.class}: #{e.message}")
+        Rails.logger.error(e.backtrace.first(5).join("\n"))
+      end
+      private
+      def should_defer_instrumentation?
+        CacheStache.configuration.use_rack_after_reply
+      end
+      def enqueue_after_reply_event(bucket_ts, increments)
+        Thread.current[AFTER_REPLY_QUEUE_KEY] ||= []
+        Thread.current[AFTER_REPLY_QUEUE_KEY] << [bucket_ts, increments]
+      end
+    end
+  end
+end

data/lib/cache_stache/keyspace.rb ADDED Viewed

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "active_support/core_ext/string/inflections"
+module CacheStache
+  class Keyspace
+    attr_accessor :name, :label, :pattern
+    def initialize(name)
+      @name = name
+      @label = name.to_s.humanize
+      @pattern = nil
+    end
+    def match?(key)
+      return false unless pattern
+      pattern.match?(key.to_s)
+    rescue => e
+      Rails.logger.error("CacheStache: Keyspace #{name} matcher error: #{e.message}")
+      false
+    end
+    def validate!
+      raise Error, "Keyspace #{name} requires a match pattern (regex)" unless pattern
+      raise Error, "Keyspace #{name} match pattern must be a Regexp" unless pattern.is_a?(Regexp)
+    end
+  end
+end

data/lib/cache_stache/rack_after_reply_middleware.rb ADDED Viewed

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module CacheStache
+  class RackAfterReplyMiddleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      return @app.call(env) unless CacheStache.configuration.use_rack_after_reply
+      Thread.current[CacheStache::Instrumentation::AFTER_REPLY_QUEUE_KEY] = []
+      env["rack.after_reply"] ||= []
+      env["rack.after_reply"] << lambda do
+        CacheStache::Instrumentation.flush_after_reply_queue!
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/cache_stache/railtie.rb ADDED Viewed

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module CacheStache
+  class Railtie < Rails::Railtie
+    initializer "cache_stache.middleware", after: :load_config_initializers do |app|
+      if CacheStache.configuration.use_rack_after_reply
+        app.config.middleware.use(CacheStache::RackAfterReplyMiddleware)
+      end
+    end
+    initializer "cache_stache.instrumentation", after: :load_config_initializers do
+      # Install instrumentation after initializers run so user configuration is loaded
+      if CacheStache.configuration.enabled
+        CacheStache::Instrumentation.install!
+      else
+        Rails.logger.info("CacheStache: Instrumentation disabled via configuration")
+      end
+    end
+    rake_tasks do
+      load File.expand_path("../../tasks/cache_stache.rake", __dir__)
+    end
+    initializer "cache_stache.web_reloader" do
+      ActiveSupport::Reloader.to_prepare do
+        CacheStache::Web.reset_routes!
+      end
+    end
+  end
+end