request_store_rails 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6b370ace6ec755d1dc7fa029ee24f92eb5b9caac
-  data.tar.gz: 59be0018678daaa9cf65c25305c8170fc41a9055
+SHA256:
+  metadata.gz: 7bd1299319b0c1e8167b6d68d55e69d4099439824beeac03f8a9fc0c715ee71b
+  data.tar.gz: 7d5a0b52520b5f09405ae262f5eb9c984d8faad49886e343331e76b7b1c88249
 SHA512:
-  metadata.gz: ff35f1f352936ce0858d15ec30b4e996a7e70e7d62a31137c0303000d1c374a1efa3e02ac6b03f4a7b9822297a693fc96c799ec002167ad32648a3383519349a
-  data.tar.gz: 188fda858dd967a796197b6989e16ef88878eafe72d69dd61282b02cca96487168ea3fc7dc4824f89453261f3e7518ad46f9870c5b92f1d901b6100d1a4bd338
+  metadata.gz: 1a8fd3b6848bf8b92a74610e1803349388b93cbd64f1454c5df608483fb2283022db0210c4cf7d8c797059dd3aebdd038eedad4214672a6c4eabda6c19bb019d
+  data.tar.gz: 1ff7ff9d67e0d00447a904e2e3b80b130fca8a24b92759f6d2fd0d4cdcc8878fb28d958e58e7dd9eb1272faa1e5f7e2f47c99ff9d2d8f6c13446528256f4218b

data/README.md

@@ -77,11 +77,11 @@ use RequestStoreRails::Middleware
 ```
 
 ## Multi-Threading
-The middleware in the gem sets a thread-local variable `:request_id` in
+The middleware in the gem sets a thread-local variable `:request_store_id` in
 `Thread.current` for the main thread that is executing the request.
 
 If you need to spawn threads within a server that is already using thread-based
-concurrency, all you need to do is to make sure that the `:request_id`
+concurrency, all you need to do is to make sure that the `:request_store_id`
 variable is set for your threads, and you will be able to access the
 `RequestLocals` as usual.
 
@@ -93,9 +93,9 @@ class ThreadWithContext
 
   # Public: Returns a new Thread that preserves the context of the current request.
   def ThreadWithContext.new(*args)
-    request_id = Thread.current[:request_id]
+    store_id = RequestLocals.current_store_id
     Thread.new {
-      Thread.current[:request_id] = request_id
+      RequestLocals.set_current_store_id(store_id)
       yield *args
     }
   end
@@ -133,6 +133,35 @@ if RequestStore != RequestLocals
 end
 ```
 
+## Usage in Sidekiq
+If your code depends on these global variables, it's likely that you'll need
+to avoid collisions in Sidekiq workers (which would happen if the current store
+id is `nil`).
+
+You can use the following middleware, using the job id to identify the store:
+
+```ruby
+class Sidekiq::Middleware::Server::RequestStoreRails
+  def call(_worker, job, _queue)
+    RequestLocals.set_current_store_id(job['jid'])
+    yield
+  ensure
+    RequestLocals.clear!
+    RequestLocals.set_current_store_id(nil)
+  end
+end
+```
+
+Make sure to configure it as server middleware:
+
+```ruby
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Middleware::Server::RequestStoreRails
+  end
+end
+```
+
 ## Special Thanks
 The inspiration for this gem, tests, and a big part of the readme were borrowed
 from the really cool [`request_store`](https://github.com/steveklabnik/request_store) gem.

data/lib/request_locals.rb

@@ -5,8 +5,8 @@ require 'concurrent'
 # Public: Provides per-request global storage, by offering an interface that is
 # very similar to Rails.cache, or Hash.
 #
-# The store may be shared between threads, as long as the :request_id
-# thread-local variable is set.
+# The store may be shared between threads, as long as the current store id is
+# set as a thread-local variable.
 #
 # Intended to work in collaboration with the RequestStoreRails middleware, that
 # will clear the request local variables after each request.
@@ -14,11 +14,15 @@ class RequestLocals
   include Singleton
   extend Forwardable
 
+  # Internal: The key of the thread-local variable the library uses to store the
+  # identifier of the current store, used during the request lifecycle.
+  REQUEST_STORE_ID = :request_store_id
+
   class << self
     extend Forwardable
 
     # Public: Public methods of RequestLocals, they are delegated to the Singleton instance.
-    def_delegators :instance, :clear!, :clear_all!, :[], :[]=, :fetch, :delete, :exist?, :key?, :empty?
+    def_delegators :instance, :clear!, :clear_all!, :current_store_id, :[], :[]=, :fetch, :delete, :exist?, :key?, :empty?
 
     # Public: There is no accounting for taste, RequestLocals[:foo] vs RequestLocals.store[:foo]
     alias_method :store, :instance
@@ -46,7 +50,7 @@ class RequestLocals
   #
   # Returns nothing.
   def clear!
-    @cache.delete(current_request_id)
+    @cache.delete(current_store_id)
   end
 
   # Public: Clears all the request-local variable stores.
@@ -75,6 +79,19 @@ class RequestLocals
     store.compute_if_absent(key, &block)
   end
 
+  # Public: The current request is inferred from the current thread.
+  #
+  # NOTE: It's very important to set the current store id when spawning new
+  # threads within a single request, using `RequestLocals.set_current_store_id`.
+  def current_store_id
+    Thread.current[REQUEST_STORE_ID]
+  end
+
+  # Public: Changes the store RequestLocals will read from in the current thread.
+  def self.set_current_store_id(id)
+    Thread.current[REQUEST_STORE_ID] = id
+  end
+
 protected
 
   # Internal: Returns the structure that holds the request-local variables for
@@ -82,14 +99,7 @@ protected
   #
   # Returns a ThreadSafe::Cache.
   def store
-    @cache.compute_if_absent(current_request_id) { new_store }
-  end
-
-  # Internal: The current request is inferred from the current thread. It's very
-  # important to pass on the :request_id thread local variable when spawning new
-  # threads within a single request.
-  def current_request_id
-    Thread.current[:request_id]
+    @cache.compute_if_absent(current_store_id) { new_store }
   end
 
   # Internal: Returns a new empty structure where the request-local variables

data/lib/request_store_rails/middleware.rb

@@ -2,29 +2,33 @@ require 'securerandom'
 
 module RequestStoreRails
 
-  # Public: Middleware that takes care of setting the thread-local variable
-  # :request_id, which enables RequestLocals to associate threads and requests.
+  # Public: Middleware that takes care of setting a thread-local variable, which
+  # enables RequestLocals to associate threads with the store for a request.
   class Middleware
 
     def initialize(app)
       @app = app
     end
 
-    # Internal: Assigns the :request_id thread-local variable, and cleans up all
-    # the request-local variables after the request.
+    # Internal: Assigns a thread-local variable to identify the current store,
+    # and cleans up all the variables stored for the request once it finishes.
     def call(env)
-      Thread.current[:request_id] = extract_request_id(env)
+      RequestLocals.set_current_store_id(extract_request_id(env))
       @app.call(env)
     ensure
       RequestLocals.clear!
-      Thread.current[:request_id] = nil
+      RequestLocals.set_current_store_id(nil)
     end
 
   protected
 
     # Internal: Extracts the request id from the environment, or generates one.
+    #
+    # NOTE: We always generate an id to prevent accidental conflicts from an
+    # externally provided one, but subclasses of this middleware might override
+    # it.
     def extract_request_id(env)
-      env['action_dispatch.request_id'] || env['HTTP_X_REQUEST_ID'] || SecureRandom.hex(16)
+      SecureRandom.uuid
     end
   end
 end

data/lib/request_store_rails/version.rb

@@ -1,4 +1,4 @@
 module RequestStoreRails
 
-  VERSION = '1.0.3'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: request_store_rails
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Máximo Mussini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-06 00:00:00.000000000 Z
+date: 2019-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -86,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Per-request global storage for Rails