ugly but functoinal parallelization

application_controller.rb

def some_before_filter
  @parallel_resources ||= []
  @parallel_resources << { :member => Proc.new { FetchMember.new({
    cache: Rails.cache,
    cache_key: [:profile, token],
    member_class: Member,
    token: token,
    site_key: site_key
  }).call.data } }

  @promises = Concurrent::Promise.zip(*@parallel_resources.map{ |x| Concurrent::Promise.new { Druthers.load(request.host, &Druthers::Config.source); config_connections; { x.keys.first => x.values.first.call } } } )

  @member = @promises.value.detect {|el| el.key?(:member) }.values.last
end

promotions_controller.rb

class PromotionsController < ApplicationController
  prepend_before_filter :parallel_resource

  def index
    @promotions = @promises.value.detect {|el| el.key?(:promotions) }.values.last
    render layout: "logged_in"
  end

  private
  def fetch_promotions
    FetchPromotions.new({
      cache: Rails.cache,
      cache_key: session[:program_code].present? ? "#{token}-#{session[:program_code]}-promotions" : "#{token}-promotions",
      program_filter: session[:program_code],
      token: token,
      decorator: Promotion::Generic
    }).call.data
  end

  def parallel_resource
    @parallel_resources = [ { :promotions => Proc.new { fetch_promotions } } ]
  end
end