How can I intercept requests to a mounted Sidekiq app in Rails?

Feeling very silly because, I realized that I already had the solution. For some reason the logging I was using to track what controllers were being hit was not working and I thought they were being bypassed. After realizing that and resolving the issue, here's what I discovered.

In our the routes file, the mounting of sidekiq was being wrapped in an authenticate call. This method was provided by Devise.

RUBYCopied
  # routes.rb
  devise_for :users, controllers: { saml_sessions: "users/saml_sessions" }

  authenticate :user, ->(user) { user.admin? } do
    mount Sidekiq::Web => '/sidekiq'
  end

This meant that, if the user was logged out and navigated to /sidekiq, the request would hit our custom SessionsController that was configured for Devise to use. Users::SamlSessionsController inherits from Devise::SamlSessionsController which eventually inherits from the base ApplicationController. So any before_actions defined there will run.

One issue, however, is that when the request hits the Users::SamlSessionsController it has been redirected from /sidekiq. So the request.fullpath is no longer available to store or reference.

However, it turns out that Devise saves this to the session before redirecting to Users::SamlSessionsController. For me, it was sessions[:user_return_to]. It's also returned (and cleared) by calling stored_location_for.

The Sidekiq::Web app is really just a basic Rack application built on a truly tiny microframework.

Rack applications have a really simple interface which is just a .call(env) method which returns an array that looks like:

RUBYCopied
# Status code, env hash, response body
[200, {}, ["Hello World"]]

Both the router and controllers in Rails are Rack applications so passing the request down one more layer is no biggie.

RUBYCopied
# config/routes.rb
scope 'sidekiq' do
  match '(*path)', via: :all, to: 'my_sidekiq#proxy'
end

RUBYCopied
# app/controllers/my_sidekiq_controller.rb
class MySidekiqController < ApplicationController
  # Serves as a catch all route that forwards requests to sidekiq which has it's own router. 
  def proxy
    status, *, body = Sidekiq::Web.call(prepare_env)
    # there is probably a more elegant way to set the response 
    # and prevent implicit rendering
    render body: body, status: status
  end

  private 

  # This removes the `/sidekiq` segment from the env hash as 
  # sidekiq doesn't have it when routing internally. Thanks Alex.
  # The params might need additional processing if you intend to catch the POST routes as well
  def prepare_env
    cleaned_path = request.env['PATH_INFO'].remove('/sidekiq')
    request.env.merge(
      'PATH_INFO' => cleaned_path
    )
  end
end

You now have turned your controller into makeshift middleware.

Although a cleaner solution is most likely to move your tracking functionality into the middleware layer instead of relying on a controller callback.

You mentioned in your comments that you want to store a location before handing off the request to the Sidekiq Rack App. Try checking out routing constraints.

This sounds pretty similar to a lot of the examples that Mike Perham has in the Sidekiq Wiki for adding in authentication wrappers around Sidekiq::Web - https://github.com/sidekiq/sidekiq/wiki/Monitoring#authentication. Here's an example:

RUBYCopied
# lib/admin_constraint.rb
class AdminConstraint
  def matches?(request)
    return false unless request.session[:user_id]
    user = User.find request.session[:user_id]
    user && user.admin?
  end
end

# config/routes.rb
require 'sidekiq/web'
require 'admin_constraint'
mount Sidekiq::Web => '/sidekiq', :constraints => AdminConstraint.new

Of course, you won't be able to call your before_action with this approach, but you could store the destination path in the request and use it later.

If you really want to be DRY, you could look at making a custom middleware that you insert into the middleware chain that keeps track of the intended path. I'm pretty sure frameworks like Devise do this automatically for you.