sidekiq 7.3.0 → 8.0.5

data/lib/sidekiq/web/application.rb

@@ -1,479 +1,457 @@
 # frozen_string_literal: true
 
-module Sidekiq
-  class WebApplication
-    extend WebRouter
-
-    REDIS_KEYS = %w[redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human]
-    CSP_HEADER_TEMPLATE = [
-      "default-src 'self' https: http:",
-      "child-src 'self'",
-      "connect-src 'self' https: http: wss: ws:",
-      "font-src 'self' https: http:",
-      "frame-src 'self'",
-      "img-src 'self' https: http: data:",
-      "manifest-src 'self'",
-      "media-src 'self'",
-      "object-src 'none'",
-      "script-src 'self' 'nonce-!placeholder!'",
-      "style-src 'self' https: http: 'unsafe-inline'", # TODO Nonce in 8.0
-      "worker-src 'self'",
-      "base-uri 'self'"
-    ].join("; ").freeze
-    METRICS_PERIODS = {
-      "1h" => 60,
-      "2h" => 120,
-      "4h" => 240,
-      "8h" => 480
-    }
-
-    def initialize(klass)
-      @klass = klass
-    end
+require "sidekiq/paginator"
+require "sidekiq/web/helpers"
 
-    def settings
-      @klass.settings
-    end
-
-    def self.settings
-      Sidekiq::Web.settings
-    end
-
-    def self.tabs
-      Sidekiq::Web.tabs
-    end
-
-    def self.set(key, val)
-      # nothing, backwards compatibility
-    end
-
-    head "/" do
-      # HEAD / is the cheapest heartbeat possible,
-      # it hits Redis to ensure connectivity and returns
-      # the size of the default queue
-      Sidekiq.redis { |c| c.llen("queue:default") }.to_s
-    end
-
-    get "/" do
-      @redis_info = redis_info.select { |k, v| REDIS_KEYS.include? k }
-      days = (params["days"] || 30).to_i
-      return halt(401) if days < 1 || days > 180
-
-      stats_history = Sidekiq::Stats::History.new(days)
-      @processed_history = stats_history.processed
-      @failed_history = stats_history.failed
+module Sidekiq
+  class Web
+    class Application
+      extend Router
+      include Router
+
+      REDIS_KEYS = %w[redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human]
+
+      CSP_HEADER_TEMPLATE = [
+        "default-src 'self' https: http:",
+        "child-src 'self'",
+        "connect-src 'self' https: http: wss: ws:",
+        "font-src 'none'",
+        "frame-src 'self'",
+        "img-src 'self' https: http: data:",
+        "manifest-src 'self'",
+        "media-src 'self'",
+        "object-src 'none'",
+        "script-src 'self' 'nonce-!placeholder!'",
+        "style-src 'self' 'nonce-!placeholder!'",
+        "worker-src 'self'",
+        "base-uri 'self'"
+      ].join("; ").freeze
+
+      METRICS_PERIODS = {
+        "1h" => {minutes: 60},
+        "2h" => {minutes: 120},
+        "4h" => {minutes: 240},
+        "8h" => {minutes: 480},
+        "24h" => {hours: 24},
+        "48h" => {hours: 48},
+        "72h" => {hours: 72}
+      }
 
-      erb(:dashboard)
-    end
+      def initialize(inst)
+        @app = inst
+      end
 
-    get "/metrics" do
-      q = Sidekiq::Metrics::Query.new
-      @period = h((params[:period] || "")[0..1])
-      @periods = METRICS_PERIODS
-      minutes = @periods.fetch(@period, @periods.values.first)
-      @query_result = q.top_jobs(minutes: minutes)
-      erb(:metrics)
-    end
+      head "/" do
+        # HEAD / is the cheapest heartbeat possible,
+        # it hits Redis to ensure connectivity
+        _ = Sidekiq.redis { |c| c.llen("queue:default") }
+        ""
+      end
 
-    get "/metrics/:name" do
-      @name = route_params[:name]
-      @period = h((params[:period] || "")[0..1])
-      q = Sidekiq::Metrics::Query.new
-      @periods = METRICS_PERIODS
-      minutes = @periods.fetch(@period, @periods.values.first)
-      @query_result = q.for_job(@name, minutes: minutes)
-      erb(:metrics_for_job)
-    end
+      get "/" do
+        @redis_info = redis_info.slice(*REDIS_KEYS)
+        days = (url_params("days") || 30).to_i
+        return halt(401) if days < 1 || days > 180
 
-    get "/busy" do
-      @count = (params["count"] || 100).to_i
-      (@current_page, @total_size, @workset) = page_items(workset, params["page"], @count)
+        stats_history = Sidekiq::Stats::History.new(days)
+        @processed_history = stats_history.processed
+        @failed_history = stats_history.failed
 
-      erb(:busy)
-    end
+        erb(:dashboard)
+      end
 
-    post "/busy" do
-      if params["identity"]
-        pro = Sidekiq::ProcessSet[params["identity"]]
+      get "/metrics" do
+        x = url_params("substr")
+        class_filter = (x.nil? || x == "") ? nil : Regexp.new(Regexp.escape(x), Regexp::IGNORECASE)
 
-        pro.quiet! if params["quiet"]
-        pro.stop! if params["stop"]
-      else
-        processes.each do |pro|
-          next if pro.embedded?
+        q = Sidekiq::Metrics::Query.new
+        @period = h(url_params("period") || "1h")
+        @periods = METRICS_PERIODS
+        args = @periods.fetch(@period, @periods.values.first)
+        @query_result = q.top_jobs(**args.merge(class_filter: class_filter))
 
-          pro.quiet! if params["quiet"]
-          pro.stop! if params["stop"]
-        end
+        header "refresh", 60 if @period == "1h"
+        erb(:metrics)
       end
 
-      redirect "#{root_path}busy"
-    end
-
-    get "/queues" do
-      @queues = Sidekiq::Queue.all
+      get "/metrics/:name" do
+        @name = route_params(:name)
+        @period = h(url_params("period") || "1h")
+        # Periods larger than 8 hours are not supported for histogram chart
+        @period = "8h" if @period.to_i > 8
+        @periods = METRICS_PERIODS.reject { |k, v| k.to_i > 8 }
+        args = @periods.fetch(@period, @periods.values.first)
+        q = Sidekiq::Metrics::Query.new
+        @query_result = q.for_job(@name, **args)
+
+        header "refresh", 60 if @period == "1h"
+        erb(:metrics_for_job)
+      end
 
-      erb(:queues)
-    end
+      get "/busy" do
+        @count = (url_params("count") || 100).to_i
+        (@current_page, @total_size, @workset) = page_items(workset, url_params("page"), @count)
 
-    QUEUE_NAME = /\A[a-z_:.\-0-9]+\z/i
+        erb(:busy)
+      end
 
-    get "/queues/:name" do
-      @name = route_params[:name]
+      post "/busy" do
+        if url_params("identity")
+          pro = Sidekiq::ProcessSet[url_params("identity")]
 
-      halt(404) if !@name || @name !~ QUEUE_NAME
+          pro.quiet! if url_params("quiet")
+          pro.stop! if url_params("stop")
+        else
+          processes.each do |pro|
+            next if pro.embedded?
 
-      @count = (params["count"] || 25).to_i
-      @queue = Sidekiq::Queue.new(@name)
-      (@current_page, @total_size, @jobs) = page("queue:#{@name}", params["page"], @count, reverse: params["direction"] == "asc")
-      @jobs = @jobs.map { |msg| Sidekiq::JobRecord.new(msg, @name) }
+            pro.quiet! if url_params("quiet")
+            pro.stop! if url_params("stop")
+          end
+        end
 
-      erb(:queue)
-    end
+        redirect "#{root_path}busy"
+      end
 
-    post "/queues/:name" do
-      queue = Sidekiq::Queue.new(route_params[:name])
+      get "/queues" do
+        @queues = Sidekiq::Queue.all
 
-      if Sidekiq.pro? && params["pause"]
-        queue.pause!
-      elsif Sidekiq.pro? && params["unpause"]
-        queue.unpause!
-      else
-        queue.clear
+        erb(:queues)
       end
 
-      redirect "#{root_path}queues"
-    end
+      QUEUE_NAME = /\A[a-z_:.\-0-9]+\z/i
 
-    post "/queues/:name/delete" do
-      name = route_params[:name]
-      Sidekiq::JobRecord.new(params["key_val"], name).delete
+      get "/queues/:name" do
+        @name = route_params(:name)
 
-      redirect_with_query("#{root_path}queues/#{CGI.escape(name)}")
-    end
+        halt(404) if !@name || @name !~ QUEUE_NAME
 
-    get "/morgue" do
-      @count = (params["count"] || 25).to_i
-      (@current_page, @total_size, @dead) = page("dead", params["page"], @count, reverse: true)
-      @dead = @dead.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        @count = (url_params("count") || 25).to_i
+        @queue = Sidekiq::Queue.new(@name)
+        (@current_page, @total_size, @jobs) = page("queue:#{@name}", url_params("page"), @count, reverse: url_params("direction") == "asc")
+        @jobs = @jobs.map { |msg| Sidekiq::JobRecord.new(msg, @name) }
 
-      erb(:morgue)
-    end
+        erb(:queue)
+      end
 
-    get "/morgue/:key" do
-      key = route_params[:key]
-      halt(404) unless key
+      post "/queues/:name" do
+        queue = Sidekiq::Queue.new(route_params(:name))
 
-      @dead = Sidekiq::DeadSet.new.fetch(*parse_params(key)).first
+        if Sidekiq.pro? && url_params("pause")
+          queue.pause!
+        elsif Sidekiq.pro? && url_params("unpause")
+          queue.unpause!
+        else
+          queue.clear
+        end
 
-      if @dead.nil?
-        redirect "#{root_path}morgue"
-      else
-        erb(:dead)
+        redirect "#{root_path}queues"
       end
-    end
 
-    post "/morgue" do
-      redirect(request.path) unless params["key"]
+      post "/queues/:name/delete" do
+        name = route_params(:name)
+        Sidekiq::JobRecord.new(url_params("key_val"), name).delete
 
-      params["key"].each do |key|
-        job = Sidekiq::DeadSet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
+        redirect_with_query("#{root_path}queues/#{CGI.escape(name)}")
       end
 
-      redirect_with_query("#{root_path}morgue")
-    end
-
-    post "/morgue/all/delete" do
-      Sidekiq::DeadSet.new.clear
-
-      redirect "#{root_path}morgue"
-    end
-
-    post "/morgue/all/retry" do
-      Sidekiq::DeadSet.new.retry_all
+      get "/morgue" do
+        x = url_params("substr")
 
-      redirect "#{root_path}morgue"
-    end
+        if x && x != ""
+          @dead = search(Sidekiq::DeadSet.new, x)
+        else
+          @count = (url_params("count") || 25).to_i
+          (@current_page, @total_size, @dead) = page("dead", url_params("page"), @count, reverse: true)
+          @dead = @dead.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        end
 
-    post "/morgue/:key" do
-      key = route_params[:key]
-      halt(404) unless key
+        erb(:morgue)
+      end
 
-      job = Sidekiq::DeadSet.new.fetch(*parse_params(key)).first
-      retry_or_delete_or_kill job, params if job
+      get "/morgue/:key" do
+        key = route_params(:key)
+        halt(404) unless key
 
-      redirect_with_query("#{root_path}morgue")
-    end
+        @dead = Sidekiq::DeadSet.new.fetch(*parse_key(key)).first
 
-    get "/retries" do
-      @count = (params["count"] || 25).to_i
-      (@current_page, @total_size, @retries) = page("retry", params["page"], @count)
-      @retries = @retries.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        if @dead.nil?
+          redirect "#{root_path}morgue"
+        else
+          erb(:dead)
+        end
+      end
 
-      erb(:retries)
-    end
+      post "/morgue" do
+        redirect(request.path) unless url_params("key")
 
-    get "/retries/:key" do
-      @retry = Sidekiq::RetrySet.new.fetch(*parse_params(route_params[:key])).first
+        url_params("key").each do |key|
+          job = Sidekiq::DeadSet.new.fetch(*parse_key(key)).first
+          retry_or_delete_or_kill job, request.params if job
+        end
 
-      if @retry.nil?
-        redirect "#{root_path}retries"
-      else
-        erb(:retry)
+        redirect_with_query("#{root_path}morgue")
       end
-    end
 
-    post "/retries" do
-      redirect(request.path) unless params["key"]
+      post "/morgue/all/delete" do
+        Sidekiq::DeadSet.new.clear
 
-      params["key"].each do |key|
-        job = Sidekiq::RetrySet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
+        redirect "#{root_path}morgue"
       end
 
-      redirect_with_query("#{root_path}retries")
-    end
-
-    post "/retries/all/delete" do
-      Sidekiq::RetrySet.new.clear
+      post "/morgue/all/retry" do
+        Sidekiq::DeadSet.new.retry_all
 
-      redirect "#{root_path}retries"
-    end
+        redirect "#{root_path}morgue"
+      end
 
-    post "/retries/all/retry" do
-      Sidekiq::RetrySet.new.retry_all
+      post "/morgue/:key" do
+        key = route_params(:key)
+        halt(404) unless key
 
-      redirect "#{root_path}retries"
-    end
+        job = Sidekiq::DeadSet.new.fetch(*parse_key(key)).first
+        retry_or_delete_or_kill job, request.params if job
 
-    post "/retries/all/kill" do
-      Sidekiq::RetrySet.new.kill_all
+        redirect_with_query("#{root_path}morgue")
+      end
 
-      redirect "#{root_path}retries"
-    end
+      get "/retries" do
+        x = url_params("substr")
 
-    post "/retries/:key" do
-      job = Sidekiq::RetrySet.new.fetch(*parse_params(route_params[:key])).first
+        if x && x != ""
+          @retries = search(Sidekiq::RetrySet.new, x)
+        else
+          @count = (url_params("count") || 25).to_i
+          (@current_page, @total_size, @retries) = page("retry", url_params("page"), @count)
+          @retries = @retries.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        end
 
-      retry_or_delete_or_kill job, params if job
+        erb(:retries)
+      end
 
-      redirect_with_query("#{root_path}retries")
-    end
+      get "/retries/:key" do
+        @retry = Sidekiq::RetrySet.new.fetch(*parse_key(route_params(:key))).first
 
-    get "/scheduled" do
-      @count = (params["count"] || 25).to_i
-      (@current_page, @total_size, @scheduled) = page("schedule", params["page"], @count)
-      @scheduled = @scheduled.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        if @retry.nil?
+          redirect "#{root_path}retries"
+        else
+          erb(:retry)
+        end
+      end
 
-      erb(:scheduled)
-    end
+      post "/retries" do
+        redirect(request.path) unless url_params("key")
 
-    get "/scheduled/:key" do
-      @job = Sidekiq::ScheduledSet.new.fetch(*parse_params(route_params[:key])).first
+        url_params("key").each do |key|
+          job = Sidekiq::RetrySet.new.fetch(*parse_key(key)).first
+          retry_or_delete_or_kill job, request.params if job
+        end
 
-      if @job.nil?
-        redirect "#{root_path}scheduled"
-      else
-        erb(:scheduled_job_info)
+        redirect_with_query("#{root_path}retries")
       end
-    end
 
-    post "/scheduled" do
-      redirect(request.path) unless params["key"]
-
-      params["key"].each do |key|
-        job = Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first
-        delete_or_add_queue job, params if job
+      post "/retries/all/delete" do
+        Sidekiq::RetrySet.new.clear
+        redirect "#{root_path}retries"
       end
 
-      redirect_with_query("#{root_path}scheduled")
-    end
+      post "/retries/all/retry" do
+        Sidekiq::RetrySet.new.retry_all
+        redirect "#{root_path}retries"
+      end
 
-    post "/scheduled/:key" do
-      key = route_params[:key]
-      halt(404) unless key
+      post "/retries/all/kill" do
+        Sidekiq::RetrySet.new.kill_all
+        redirect "#{root_path}retries"
+      end
 
-      job = Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first
-      delete_or_add_queue job, params if job
+      post "/retries/:key" do
+        job = Sidekiq::RetrySet.new.fetch(*parse_key(route_params(:key))).first
 
-      redirect_with_query("#{root_path}scheduled")
-    end
+        retry_or_delete_or_kill job, request.params if job
 
-    get "/dashboard/stats" do
-      redirect "#{root_path}stats"
-    end
+        redirect_with_query("#{root_path}retries")
+      end
 
-    get "/stats" do
-      sidekiq_stats = Sidekiq::Stats.new
-      redis_stats = redis_info.select { |k, v| REDIS_KEYS.include? k }
-      json(
-        sidekiq: {
-          processed: sidekiq_stats.processed,
-          failed: sidekiq_stats.failed,
-          busy: sidekiq_stats.workers_size,
-          processes: sidekiq_stats.processes_size,
-          enqueued: sidekiq_stats.enqueued,
-          scheduled: sidekiq_stats.scheduled_size,
-          retries: sidekiq_stats.retry_size,
-          dead: sidekiq_stats.dead_size,
-          default_latency: sidekiq_stats.default_queue_latency
-        },
-        redis: redis_stats,
-        server_utc_time: server_utc_time
-      )
-    end
+      get "/scheduled" do
+        x = url_params("substr")
 
-    get "/stats/queues" do
-      json Sidekiq::Stats.new.queues
-    end
-
-    ########
-    # Filtering
+        if x && x != ""
+          @scheduled = search(Sidekiq::ScheduledSet.new, x)
+        else
+          @count = (url_params("count") || 25).to_i
+          (@current_page, @total_size, @scheduled) = page("schedule", url_params("page"), @count)
+          @scheduled = @scheduled.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+        end
 
-    get "/filter/metrics" do
-      redirect "#{root_path}metrics"
-    end
+        erb(:scheduled)
+      end
 
-    post "/filter/metrics" do
-      x = params[:substr]
-      q = Sidekiq::Metrics::Query.new
-      @period = h((params[:period] || "")[0..1])
-      @periods = METRICS_PERIODS
-      minutes = @periods.fetch(@period, @periods.values.first)
-      @query_result = q.top_jobs(minutes: minutes, class_filter: Regexp.new(Regexp.escape(x), Regexp::IGNORECASE))
+      get "/scheduled/:key" do
+        @job = Sidekiq::ScheduledSet.new.fetch(*parse_key(route_params(:key))).first
 
-      erb :metrics
-    end
+        if @job.nil?
+          redirect "#{root_path}scheduled"
+        else
+          erb(:scheduled_job_info)
+        end
+      end
 
-    get "/filter/retries" do
-      x = params[:substr]
-      return redirect "#{root_path}retries" unless x && x != ""
+      post "/scheduled" do
+        redirect(request.path) unless url_params("key")
 
-      @retries = search(Sidekiq::RetrySet.new, params[:substr])
-      erb :retries
-    end
+        url_params("key").each do |key|
+          job = Sidekiq::ScheduledSet.new.fetch(*parse_key(key)).first
+          delete_or_add_queue job, request.params if job
+        end
 
-    post "/filter/retries" do
-      x = params[:substr]
-      return redirect "#{root_path}retries" unless x && x != ""
+        redirect_with_query("#{root_path}scheduled")
+      end
 
-      @retries = search(Sidekiq::RetrySet.new, params[:substr])
-      erb :retries
-    end
+      post "/scheduled/:key" do
+        key = route_params(:key)
+        halt(404) unless key
 
-    get "/filter/scheduled" do
-      x = params[:substr]
-      return redirect "#{root_path}scheduled" unless x && x != ""
+        job = Sidekiq::ScheduledSet.new.fetch(*parse_key(key)).first
+        delete_or_add_queue job, request.params if job
 
-      @scheduled = search(Sidekiq::ScheduledSet.new, params[:substr])
-      erb :scheduled
-    end
+        redirect_with_query("#{root_path}scheduled")
+      end
 
-    post "/filter/scheduled" do
-      x = params[:substr]
-      return redirect "#{root_path}scheduled" unless x && x != ""
+      get "/dashboard/stats" do
+        redirect "#{root_path}stats"
+      end
 
-      @scheduled = search(Sidekiq::ScheduledSet.new, params[:substr])
-      erb :scheduled
-    end
+      get "/stats" do
+        sidekiq_stats = Sidekiq::Stats.new
+        redis_stats = redis_info.slice(*REDIS_KEYS)
+        redis_stats["store_name"] = store_name
+        redis_stats["store_version"] = store_version
+        json(
+          sidekiq: {
+            processed: sidekiq_stats.processed,
+            failed: sidekiq_stats.failed,
+            busy: sidekiq_stats.workers_size,
+            processes: sidekiq_stats.processes_size,
+            enqueued: sidekiq_stats.enqueued,
+            scheduled: sidekiq_stats.scheduled_size,
+            retries: sidekiq_stats.retry_size,
+            dead: sidekiq_stats.dead_size,
+            default_latency: sidekiq_stats.default_queue_latency
+          },
+          redis: redis_stats,
+          server_utc_time: server_utc_time
+        )
+      end
 
-    get "/filter/dead" do
-      x = params[:substr]
-      return redirect "#{root_path}morgue" unless x && x != ""
+      get "/stats/queues" do
+        json Sidekiq::Stats.new.queues
+      end
 
-      @dead = search(Sidekiq::DeadSet.new, params[:substr])
-      erb :morgue
-    end
+      get "/profiles" do
+        erb(:profiles)
+      end
 
-    post "/filter/dead" do
-      x = params[:substr]
-      return redirect "#{root_path}morgue" unless x && x != ""
+      get "/profiles/:key" do
+        store = config[:profile_store_url]
+        return redirect_to "#{root_path}profiles" unless store
+
+        key = route_params(:key)
+        sid = Sidekiq.redis { |c| c.hget(key, "sid") }
+
+        unless sid
+          require "net/http"
+          data = Sidekiq.redis { |c| c.hget(key, "data") }
+
+          store_uri = URI(store)
+          http = Net::HTTP.new(store_uri.host, store_uri.port)
+          http.use_ssl = store_uri.scheme == "https"
+          request = Net::HTTP::Post.new(store_uri.request_uri)
+          request.body = data
+          request["Accept"] = "application/vnd.firefox-profiler+json;version=1.0"
+          request["User-Agent"] = "Sidekiq #{Sidekiq::VERSION} job profiler"
+
+          resp = http.request(request)
+          # https://raw.githubusercontent.com/firefox-devtools/profiler-server/master/tools/decode_jwt_payload.py
+          rawjson = resp.body.split(".")[1].unpack1("m")
+          sid = Sidekiq.load_json(rawjson)["profileToken"]
+          Sidekiq.redis { |c| c.hset(key, "sid", sid) }
+        end
+        url = config[:profile_view_url] % sid
+        redirect_to url
+      end
 
-      @dead = search(Sidekiq::DeadSet.new, params[:substr])
-      erb :morgue
-    end
+      get "/profiles/:key/data" do
+        key = route_params(:key)
+        data = Sidekiq.redis { |c| c.hget(key, "data") }
 
-    post "/change_locale" do
-      locale = params["locale"]
+        [200, {
+          "content-type" => "application/json",
+          "content-encoding" => "gzip",
+          # allow Firefox Profiler's XHR to fetch this profile data
+          "access-control-allow-origin" => "*"
+        }, [data]]
+      end
 
-      match = available_locales.find { |available|
-        locale == available
-      }
+      post "/change_locale" do
+        locale = url_params("locale")
 
-      session[:locale] = match if match
+        match = available_locales.find { |available|
+          locale == available
+        }
 
-      reload_page
-    end
+        session[:locale] = match if match
 
-    def call(env)
-      action = self.class.match(env)
-      return [404, {Rack::CONTENT_TYPE => "text/plain", Web::X_CASCADE => "pass"}, ["Not Found"]] unless action
+        reload_page
+      end
 
-      app = @klass
-      resp = catch(:halt) do
-        self.class.run_befores(app, action)
-        action.instance_exec env, &action.block
-      ensure
-        self.class.run_afters(app, action)
+      def redis(&)
+        Thread.current[:sidekiq_redis_pool].with(&)
       end
 
-      case resp
-      when Array
-        # redirects go here
-        resp
-      else
-        # rendered content goes here
+      def call(env)
+        action = match(env)
+        return [404, {"content-type" => "text/plain", "x-cascade" => "pass"}, ["Not Found"]] unless action
+
         headers = {
-          Rack::CONTENT_TYPE => "text/html",
-          Rack::CACHE_CONTROL => "private, no-store",
-          Web::CONTENT_LANGUAGE => action.locale,
-          Web::CONTENT_SECURITY_POLICY => process_csp(env, CSP_HEADER_TEMPLATE)
+          "content-type" => "text/html",
+          "cache-control" => "private, no-store",
+          "content-language" => action.locale,
+          "content-security-policy" => process_csp(env, CSP_HEADER_TEMPLATE),
+          "x-content-type-options" => "nosniff"
         }
-        # we'll let Rack calculate Content-Length for us.
-        [200, headers, [resp]]
-      end
-    end
-
-    def process_csp(env, input)
-      input.gsub("!placeholder!", env[:csp_nonce])
-    end
+        env["response_headers"] = headers
+        resp = catch(:halt) do
+          Thread.current[:sidekiq_redis_pool] = env[:redis_pool]
+          action.instance_exec env, &action.block
+        ensure
+          Thread.current[:sidekiq_redis_pool] = nil
+        end
 
-    def self.helpers(mod = nil, &block)
-      if block
-        WebAction.class_eval(&block)
-      else
-        WebAction.send(:include, mod)
+        case resp
+        when Array
+          # redirects go here
+          resp
+        else
+          # rendered content goes here
+          # we'll let Rack calculate Content-Length for us.
+          [200, env["response_headers"], [resp]]
+        end
       end
-    end
-
-    def self.before(path = nil, &block)
-      befores << [path && Regexp.new("\\A#{path.gsub("*", ".*")}\\z"), block]
-    end
-
-    def self.after(path = nil, &block)
-      afters << [path && Regexp.new("\\A#{path.gsub("*", ".*")}\\z"), block]
-    end
-
-    def self.run_befores(app, action)
-      run_hooks(befores, app, action)
-    end
-
-    def self.run_afters(app, action)
-      run_hooks(afters, app, action)
-    end
-
-    def self.run_hooks(hooks, app, action)
-      hooks.select { |p, _| !p || p =~ action.env[WebRouter::PATH_INFO] }
-        .each { |_, b| action.instance_exec(action.env, app, &b) }
-    end
 
-    def self.befores
-      @befores ||= []
-    end
+      def process_csp(env, input)
+        input.gsub("!placeholder!", env[:csp_nonce])
+      end
 
-    def self.afters
-      @afters ||= []
+      # Used by extensions to add helper methods accessible to
+      # any defined endpoints in Application. Careful with generic
+      # method naming as there's no namespacing so collisions are
+      # possible.
+      def self.helpers(mod)
+        Sidekiq::Web::Action.send(:include, mod)
+      end
+      helpers WebHelpers
+      helpers Paginator
     end
   end
 end