solid_queue_monitor 1.3.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03dcf6baf00328ad18dadaaf499e82d178d7e62c7cc01433f48a1e222c245742
-  data.tar.gz: 15172ad03509c92f8d86b1c06cc78695203f125576838796d15c644c3b4a7eb0
+  metadata.gz: 92ff7e193202f9653de1b877d2e5d8b2f841c1e50e6c86a9ba4c556782e1fe8b
+  data.tar.gz: 2d180ede70f06618f676d167674238e4e7940e02f0b5af56b2667f543ab833f0
 SHA512:
-  metadata.gz: 9b973471c7ac561b9b527dbb710610b41d452325fa7edfbd58f57f0454cd1d78a932e645854b12cbfc37b02b56f36006a1fe4fc243e23b03635bd6fef2e0baff
-  data.tar.gz: 56b6b3f15cbccedbee9782cd70efe8c1c2b75b47fba7d5b4e38535a3c17386a7f355a295a44de7305efd84c2aeefc39516535d885e3f9361960564202cd2dfba
+  metadata.gz: 203a85cfcb427b2d21faf15c0203bea8c06ee8a01296ad94d318aae018ad83cd8a7c86b9ac633a300588df9a7dc012a1ba42c2a0bcc91e1b97829816e527bba2
+  data.tar.gz: 4a3904c1f727a72d47d960cfc0e20c70ffd0f0f5c62463c652d31123653956e73874661d67b15a7cdbd14b6d36aed322b946548f2906d73860f6ef12d79c4ce2

data/README.md

@@ -72,7 +72,7 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'solid_queue_monitor', '~> 1.2'
+gem 'solid_queue_monitor', '~> 2.0'
 ```
 
 Then execute:
@@ -124,6 +124,10 @@ SolidQueueMonitor.setup do |config|
   # Disable the chart on the overview page to skip chart queries entirely
   # config.show_chart = true
 end
+
+# Optional: inherit from a host-app controller to plug into your existing auth.
+# See "Custom Authentication" below. Defaults to "ActionController::Base".
+# SolidQueueMonitor.base_controller_class = 'AdminController'
 ```
 
 ### Performance at Scale
@@ -159,6 +163,48 @@ config.username = -> { Rails.application.credentials.dig(:solid_queue_monitor, :
 config.password = -> { Rails.application.credentials.dig(:solid_queue_monitor, :password) }
 ```
 
+### Custom Authentication
+
+By default, Solid Queue Monitor uses HTTP Basic auth with the username/password from `SolidQueueMonitor.setup`. To integrate with your app's existing auth (Devise, Pundit, OmniAuth, custom sessions, etc.), point the engine at a base controller from your host app:
+
+```ruby
+# config/initializers/solid_queue_monitor.rb
+SolidQueueMonitor.setup do |config|
+  config.authentication_enabled = false # disable HTTP Basic
+end
+
+# Inherit from your own controller so its before_actions, rescue_froms,
+# layout, and current_user helper cascade into the engine.
+SolidQueueMonitor.base_controller_class = 'AdminController'
+```
+
+**Minimal example — just authenticate:**
+
+```ruby
+class AdminController < ApplicationController
+  before_action :authenticate_user!   # Devise (or your equivalent)
+end
+```
+
+**Richer example — require an admin role:**
+
+```ruby
+class AdminController < ApplicationController
+  before_action :authenticate_user!
+  before_action :require_admin
+
+  private
+
+  def require_admin
+    redirect_to root_path, alert: 'Not authorized' unless current_user&.admin?
+  end
+end
+```
+
+Leave `authentication_enabled = true` if you want HTTP Basic to run *on top of* your host auth (host runs first, HTTP Basic second). Most adopters disable it.
+
+Restart your server after changing this config — the class hierarchy is set at load time, so config changes won't take effect on a live process.
+
 ## Usage
 
 After installation, visit `/solid_queue` in your browser to access the dashboard.
@@ -208,9 +254,23 @@ This makes it easy to find specific jobs when debugging issues in your applicati
 
 ## Content Security Policy
 
-Solid Queue Monitor is compatible with strict Content Security Policy as of v1.3.0.
+Solid Queue Monitor is fully CSP-compatible as of v2.0.0. The dashboard works out of the box under strict policies — no nonce configuration is required.
+
+### Strict CSP (v2.0.0+)
+
+As of v2.0 the dashboard's CSS and JavaScript are served as external, content-hashed assets (e.g. `/solid_queue/assets/application-a1b2c3d4.css`) with `Cache-Control: immutable`. The dashboard emits zero inline `<style>` or `<script>` blocks. A strict policy that only allows `'self'` for both directives is sufficient:
+
+```ruby
+# config/initializers/content_security_policy.rb
+Rails.application.config.content_security_policy do |policy|
+  policy.script_src :self
+  policy.style_src  :self
+end
+```
 
-If your application uses nonce-based CSP (the Rails default when `content_security_policy_nonce_generator` is set), Solid Queue Monitor will automatically stamp the per-request nonce onto every inline `<style>` and `<script>` tag it emits. Ensure your nonce directives include both `script-src` and `style-src`:
+### Nonce-based CSP
+
+Nonce-based CSP is also supported. When `content_security_policy_nonce_generator` is configured, Solid Queue Monitor stamps the per-request nonce onto the `<link rel="stylesheet">` and `<script src="...">` tags it emits — so policies that exclude `'self'` and only allow nonces still work:
 
 ```ruby
 # config/initializers/content_security_policy.rb
@@ -223,7 +283,9 @@ Rails.application.config.content_security_policy_nonce_generator = ->(req) { Sec
 Rails.application.config.content_security_policy_nonce_directives = %w[script-src style-src]
 ```
 
-No other configuration is required. If your application runs CSP without nonces (e.g., strict `script-src 'self'` only), the monitor UI will not function — asset-extraction support is tracked for a future release.
+### Upgrading from v1.x
+
+v1.x emitted inline `<style nonce>` and `<script nonce>` blocks, so a nonce generator was effectively required for strict policies. v2.0 removes all inline blocks. If you added a nonce generator only to make the monitor work, you can keep it (no harm) or remove it.
 
 ## Contributing
 

data/app/assets/javascripts/solid_queue_monitor/application.js

@@ -0,0 +1,393 @@
+// Solid Queue Monitor - main script
+//
+// Runtime config is read from <body data-*> attributes set by the layout.
+// CSP-safe: no eval, no inline handlers, no string-to-code.
+
+(function () {
+  'use strict';
+
+  document.addEventListener('DOMContentLoaded', function () {
+    initFlashMessage();
+    initAutoRefresh();
+    initThemeToggle();
+    initChartCollapse();
+    initChartTooltip();
+    initScheduledBulkActions();
+    initFailedJobsBulkActions();
+    initJobDetailsBehaviors();
+    initGlobalBehaviors();
+  });
+
+  function initFlashMessage() {
+    var el = document.getElementById('flash-message');
+    if (!el) return;
+
+    setTimeout(function () {
+      el.classList.add('is-fading');
+      setTimeout(function () { el.classList.add('is-hidden'); }, 500);
+    }, 5000);
+  }
+
+  function initAutoRefresh() {
+    var cfg = document.body.dataset;
+    if (cfg.autoRefreshEnabled !== 'true') return;
+
+    var refreshInterval = parseInt(cfg.autoRefreshInterval, 10) || 30;
+    var countdown = refreshInterval;
+    var timerId = null;
+    var isEnabled = localStorage.getItem('sqm_auto_refresh') !== 'false';
+
+    var toggle = document.getElementById('auto-refresh-toggle');
+    var indicator = document.getElementById('auto-refresh-indicator');
+    var countdownEl = document.getElementById('auto-refresh-countdown');
+    var refreshBtn = document.getElementById('refresh-now-btn');
+
+    function updateUI() {
+      if (toggle) toggle.checked = isEnabled;
+      if (indicator) indicator.classList.toggle('active', isEnabled);
+      if (countdownEl) {
+        countdownEl.textContent = countdown + 's';
+        countdownEl.classList.toggle('countdown-paused', !isEnabled);
+      }
+    }
+
+    function tick() {
+      countdown -= 1;
+      if (countdown <= 0) {
+        window.location.reload();
+      } else {
+        updateUI();
+      }
+    }
+
+    function stopTimer() {
+      if (timerId) {
+        clearInterval(timerId);
+        timerId = null;
+      }
+    }
+
+    function startTimer() {
+      stopTimer();
+      countdown = refreshInterval;
+      updateUI();
+      timerId = setInterval(tick, 1000);
+    }
+
+    function setEnabled(enabled) {
+      isEnabled = enabled;
+      localStorage.setItem('sqm_auto_refresh', enabled ? 'true' : 'false');
+
+      if (enabled) {
+        startTimer();
+      } else {
+        stopTimer();
+        countdown = refreshInterval;
+        updateUI();
+      }
+    }
+
+    if (toggle) {
+      toggle.addEventListener('change', function () { setEnabled(this.checked); });
+    }
+    if (refreshBtn) {
+      refreshBtn.addEventListener('click', function () { window.location.reload(); });
+    }
+
+    updateUI();
+    if (isEnabled) startTimer();
+  }
+
+  function initThemeToggle() {
+    var body = document.body;
+    var themeBtn = document.getElementById('theme-toggle-btn');
+    var storageKey = 'sqm_dark_theme';
+
+    function getPreferredTheme() {
+      var saved = localStorage.getItem(storageKey);
+      if (saved !== null) return saved === 'true';
+      return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    }
+
+    function setTheme(isDark) {
+      body.classList.toggle('dark-theme', isDark);
+      localStorage.setItem(storageKey, isDark ? 'true' : 'false');
+    }
+
+    setTheme(getPreferredTheme());
+
+    if (themeBtn) {
+      themeBtn.addEventListener('click', function () {
+        setTheme(!body.classList.contains('dark-theme'));
+      });
+    }
+
+    if (window.matchMedia) {
+      window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function (e) {
+        if (localStorage.getItem(storageKey) === null) setTheme(e.matches);
+      });
+    }
+  }
+
+  function initChartCollapse() {
+    var chartSection = document.getElementById('chart-section');
+    var toggleBtn = document.getElementById('chart-toggle-btn');
+    if (!chartSection || !toggleBtn) return;
+
+    if (localStorage.getItem('sqm_chart_collapsed') === 'true') {
+      chartSection.classList.add('collapsed');
+    }
+
+    toggleBtn.addEventListener('click', function () {
+      chartSection.classList.toggle('collapsed');
+      var collapsed = chartSection.classList.contains('collapsed');
+      localStorage.setItem('sqm_chart_collapsed', collapsed ? 'true' : 'false');
+    });
+  }
+
+  function initChartTooltip() {
+    var tooltip = document.getElementById('chart-tooltip');
+    if (!tooltip) return;
+
+    var dataPoints = document.querySelectorAll('.data-point');
+    var seriesNames = { created: 'Created', completed: 'Completed', failed: 'Failed' };
+
+    function positionTooltip(e) {
+      var x = e.clientX + 10;
+      var y = e.clientY - 30;
+
+      if (x + tooltip.offsetWidth > window.innerWidth) {
+        x = e.clientX - tooltip.offsetWidth - 10;
+      }
+      if (y < 0) {
+        y = e.clientY + 10;
+      }
+
+      tooltip.style.left = x + 'px';
+      tooltip.style.top = y + 'px';
+    }
+
+    dataPoints.forEach(function (point) {
+      point.addEventListener('mouseenter', function (e) {
+        var series = this.getAttribute('data-series');
+        var label = this.getAttribute('data-label');
+        var value = this.getAttribute('data-value');
+
+        tooltip.querySelector('.tooltip-label').textContent = label;
+        tooltip.querySelector('.tooltip-value').textContent = seriesNames[series] + ': ' + value;
+        tooltip.classList.add('tooltip-visible');
+        positionTooltip(e);
+      });
+
+      point.addEventListener('mousemove', positionTooltip);
+      point.addEventListener('mouseleave', function () {
+        tooltip.classList.remove('tooltip-visible');
+      });
+    });
+  }
+
+  function initGlobalBehaviors() {
+    document.addEventListener('submit', function (e) {
+      var form = e.target;
+      var msg = form.dataset && form.dataset.confirm;
+      if (msg && !window.confirm(msg)) e.preventDefault();
+    }, true);
+
+    document.addEventListener('click', function (e) {
+      var el = e.target.closest('[data-confirm-submit]');
+      if (!el) return;
+
+      e.preventDefault();
+      var msg = el.dataset.confirm || 'Are you sure?';
+      if (!window.confirm(msg)) return;
+
+      var formId = el.dataset.confirmSubmit;
+      var form = document.getElementById(formId);
+      if (form) form.submit();
+    });
+
+    var timeRangeSelect = document.getElementById('chart-time-select');
+    if (timeRangeSelect) {
+      timeRangeSelect.addEventListener('change', function () {
+        window.location.href = '?time_range=' + this.value;
+      });
+    }
+  }
+
+  function initScheduledBulkActions() {
+    var form = document.getElementById('scheduled-jobs-form');
+    if (!form) return;
+
+    var selectAllCheckbox = document.getElementById('scheduled-jobs-select-all');
+    var executeButton = document.getElementById('execute-selected-top');
+    var rejectButton = document.getElementById('reject-selected-top');
+
+    function selectedCheckboxes() {
+      return Array.prototype.slice.call(document.querySelectorAll('input[name="job_ids[]"]:checked'));
+    }
+
+    function allJobCheckboxes() {
+      return Array.prototype.slice.call(document.getElementsByName('job_ids[]'));
+    }
+
+    function updateButtonStates() {
+      var checked = selectedCheckboxes().length > 0;
+      if (executeButton) executeButton.disabled = !checked;
+      if (rejectButton) rejectButton.disabled = !checked;
+    }
+
+    function submitForm(actionUrl, selectedIds) {
+      allJobCheckboxes().forEach(function (checkbox) { checkbox.checked = false; });
+      Array.prototype.slice.call(form.querySelectorAll('input[type="hidden"][name="job_ids[]"]')).forEach(function (input) {
+        input.remove();
+      });
+
+      form.action = actionUrl;
+      selectedIds.forEach(function (id) {
+        var input = document.createElement('input');
+        input.type = 'hidden';
+        input.name = 'job_ids[]';
+        input.value = id;
+        form.appendChild(input);
+      });
+      form.submit();
+    }
+
+    if (selectAllCheckbox) {
+      selectAllCheckbox.addEventListener('change', function () {
+        allJobCheckboxes().forEach(function (checkbox) { checkbox.checked = selectAllCheckbox.checked; });
+        updateButtonStates();
+      });
+    }
+
+    allJobCheckboxes().forEach(function (checkbox) {
+      checkbox.addEventListener('change', function () {
+        if (selectAllCheckbox) {
+          selectAllCheckbox.checked = allJobCheckboxes().every(function (item) { return item.checked; });
+        }
+        updateButtonStates();
+      });
+    });
+
+    if (executeButton) {
+      executeButton.addEventListener('click', function () {
+        var selectedIds = selectedCheckboxes().map(function (checkbox) { return checkbox.value; });
+        if (selectedIds.length > 0) submitForm(executeButton.dataset.actionUrl, selectedIds);
+      });
+    }
+
+    if (rejectButton) {
+      rejectButton.addEventListener('click', function () {
+        var selectedIds = selectedCheckboxes().map(function (checkbox) { return checkbox.value; });
+        if (selectedIds.length === 0) return;
+        if (window.confirm('Are you sure you want to reject the selected jobs? This action cannot be undone.')) {
+          submitForm(rejectButton.dataset.actionUrl, selectedIds);
+        }
+      });
+    }
+
+    updateButtonStates();
+  }
+
+  function initFailedJobsBulkActions() {
+    var form = document.getElementById('failed-jobs-form');
+    if (!form) return;
+
+    var selectAll = document.getElementById('select-all');
+    var retryButton = document.getElementById('retry-selected-top');
+    var discardButton = document.getElementById('discard-selected-top');
+
+    function checkboxes() {
+      return Array.prototype.slice.call(document.querySelectorAll('.job-checkbox'));
+    }
+
+    function checkedBoxes() {
+      return checkboxes().filter(function (checkbox) { return checkbox.checked; });
+    }
+
+    function updateButtonState() {
+      var anyChecked = checkedBoxes().length > 0;
+      if (retryButton) retryButton.disabled = !anyChecked;
+      if (discardButton) discardButton.disabled = !anyChecked;
+    }
+
+    function appendHidden(name, value) {
+      var input = document.createElement('input');
+      input.type = 'hidden';
+      input.name = name;
+      input.value = value;
+      form.appendChild(input);
+    }
+
+    function bulkSubmit(action, promptMsg) {
+      var ids = checkedBoxes().map(function (checkbox) { return checkbox.value; });
+      if (ids.length === 0 || !window.confirm(promptMsg)) return;
+      Array.prototype.slice.call(form.querySelectorAll('input[type="hidden"]')).forEach(function (input) { input.remove(); });
+      form.action = action;
+      ids.forEach(function (id) { appendHidden('job_ids[]', id); });
+      form.submit();
+    }
+
+    if (selectAll) {
+      selectAll.addEventListener('change', function () {
+        checkboxes().forEach(function (checkbox) { checkbox.checked = selectAll.checked; });
+        updateButtonState();
+      });
+    }
+
+    checkboxes().forEach(function (checkbox) {
+      checkbox.addEventListener('change', function () {
+        if (selectAll) selectAll.checked = checkedBoxes().length === checkboxes().length;
+        updateButtonState();
+      });
+    });
+
+    if (retryButton) {
+      retryButton.addEventListener('click', function () {
+        bulkSubmit(retryButton.dataset.actionUrl, 'Are you sure you want to retry the selected jobs?');
+      });
+    }
+    if (discardButton) {
+      discardButton.addEventListener('click', function () {
+        bulkSubmit(discardButton.dataset.actionUrl, 'Are you sure you want to discard the selected jobs?');
+      });
+    }
+
+    updateButtonState();
+  }
+
+  function initJobDetailsBehaviors() {
+    document.addEventListener('click', function (e) {
+      var el = e.target.closest('[data-action]');
+      if (!el) return;
+
+      if (el.dataset.stopPropagation === 'true') e.stopPropagation();
+
+      if (el.dataset.action === 'copy') {
+        var target = document.getElementById(el.dataset.target);
+        if (!target || !navigator.clipboard) return;
+        var original = el.innerHTML;
+        navigator.clipboard.writeText(target.innerText || target.textContent).then(function () {
+          el.innerHTML = 'Copied!';
+          setTimeout(function () { el.innerHTML = original; }, 2000);
+        });
+      }
+
+      if (el.dataset.action === 'show-backtrace') {
+        var which = el.dataset.backtrace;
+        var appEl = document.getElementById('app-backtrace');
+        var fullEl = document.getElementById('full-backtrace');
+        if (appEl) appEl.classList.toggle('is-hidden', which !== 'app');
+        if (fullEl) fullEl.classList.toggle('is-hidden', which !== 'full');
+        document.querySelectorAll('[data-action="show-backtrace"]').forEach(function (btn) {
+          btn.classList.toggle('active', btn.dataset.backtrace === which);
+        });
+      }
+
+      if (el.dataset.action === 'toggle-section') {
+        var section = el.closest('.collapsible-section');
+        if (section) section.classList.toggle('is-expanded');
+      }
+    });
+  }
+}());

data/app/{services/solid_queue_monitor/stylesheet_generator.rb → assets/stylesheets/solid_queue_monitor/application.css}

@@ -1,9 +1,19 @@
-# frozen_string_literal: true
+/*
+ * Solid Queue Monitor - main stylesheet
+ *
+ * Section index:
+ *   - Resets and base typography
+ *   - Layout (container, section, header, nav)
+ *   - Stats and charts
+ *   - Tables (jobs lists, sortable headers, pagination)
+ *   - Forms (filters, search, auth-refresh toggle)
+ *   - Messages (flash, tooltips)
+ *   - Theme overrides (dark-theme)
+ *
+ * Edit this file directly. Do NOT regenerate from stylesheet_generator.rb -
+ * that class is being removed in v2.0.
+ */
 
-module SolidQueueMonitor
-  class StylesheetGenerator
-    def generate
-      <<-CSS
         .solid_queue_monitor {
           --primary-color: #3b82f6;
           --success-color: #10b981;
@@ -189,7 +199,7 @@ module SolidQueueMonitor
           white-space: nowrap;
         }
 
-        .solid_queue_monitor th,#{' '}
+        .solid_queue_monitor th, 
         .solid_queue_monitor td {
           padding: 0.75rem 1rem;
           text-align: left;
@@ -266,6 +276,11 @@ module SolidQueueMonitor
           background-color: #fffbeb;
         }
 
+        .solid_queue_monitor.dark-theme .queue-paused {
+          background-color: #3a2410;
+          color: #fde68a;
+        }
+
         .solid_queue_monitor .pause-button {
           background: #f59e0b;
           color: white;
@@ -334,7 +349,7 @@ module SolidQueueMonitor
           padding: 0.5rem 1rem;
           font-size: 0.875rem;
         }
-      #{'  '}
+        
         .solid_queue_monitor .pagination-gap {
           display: inline-flex;
           align-items: center;
@@ -507,7 +522,7 @@ module SolidQueueMonitor
         .solid_queue_monitor .filter-and-actions-container {
           flex-direction: column;
         }
-      #{'  '}
+        
         .solid_queue_monitor .bulk-actions-container {
           width: 100%;
         }
@@ -2074,7 +2089,3 @@ module SolidQueueMonitor
       #flash-message.is-fading {
         opacity: 0;
       }
-      CSS
-    end
-  end
-end

data/app/controllers/solid_queue_monitor/application_controller.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
 module SolidQueueMonitor
-  class ApplicationController < ActionController::Base
+  class ApplicationController < SolidQueueMonitor.base_controller_class.safe_constantize || ActionController::Base
     include ActionController::HttpAuthentication::Basic::ControllerMethods
     include ActionController::Flash
 
+    # Explicitly include the engine's helpers so they remain available when the
+    # host configures a custom base_controller_class. Rails auto-includes engine
+    # helpers only when the parent is ActionController::Base; inheriting from a
+    # host controller short-circuits that, breaking view methods like render_chart.
+    helper SolidQueueMonitor::Engine.helpers
+
     before_action :authenticate, if: -> { SolidQueueMonitor::AuthenticationService.authentication_required? }
-    layout false
+    layout 'solid_queue_monitor/application'
     skip_before_action :verify_authenticity_token
 
     def set_flash_message(message, type)
@@ -17,7 +23,7 @@ module SolidQueueMonitor
       # Try to use Rails flash if available
       begin
         flash[:notice] = message if type == :success
-        flash[:alert] = message if type == :error
+        flash[:alert]  = message if type == :error
       rescue StandardError
         # Flash not available (e.g., no session middleware)
       end

data/app/controllers/solid_queue_monitor/assets_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class AssetsController < ApplicationController
+    skip_before_action :authenticate, raise: false
+
+    MIME_TYPES = { '.css' => 'text/css', '.js' => 'application/javascript' }.freeze
+    FINGERPRINT_PATTERN = /\A(?<base>[A-Za-z0-9_]+)-(?<hash>[a-f0-9]+)(?<ext>\.css|\.js)\z/
+
+    def show
+      asset_request = parse_asset_request
+      return head(:not_found) unless asset_request
+
+      asset = SolidQueueMonitor::AssetCache.fetch_by_name(asset_request[:file_name])
+      return head(:not_found) unless asset
+      return head(:not_found) unless fingerprint_matches?(asset[:etag], asset_request[:hash])
+
+      assign_asset_headers(asset)
+      return head(:not_modified) if etag_matches?
+
+      render plain: asset[:content], content_type: MIME_TYPES[asset_request[:ext]]
+    end
+
+    private
+
+    def parse_asset_request
+      match = FINGERPRINT_PATTERN.match(params[:file])
+      return nil unless match
+
+      {
+        ext: match[:ext],
+        file_name: "#{match[:base]}#{match[:ext]}",
+        hash: match[:hash]
+      }
+    end
+
+    def fingerprint_matches?(expected, actual)
+      expected.bytesize == actual.bytesize && Rack::Utils.secure_compare(expected, actual)
+    end
+
+    def assign_asset_headers(asset)
+      response.headers['Cache-Control'] = "public, max-age=#{1.year.to_i}, immutable"
+      response.headers['ETag'] = %("#{asset[:etag]}")
+      response.headers['Last-Modified'] = asset[:mtime].httpdate
+      response.headers['Vary'] = 'Accept-Encoding'
+    end
+
+    def etag_matches?
+      request.headers['If-None-Match'].to_s.split(',').map(&:strip).include?(response.headers['ETag'])
+    end
+  end
+end