sidekiq-encrypted_args 1.2.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcde4f8a47a8b5b7e5a4c0d6fe8f351a5d62ec8b9390caac4697359b7efe0912
-  data.tar.gz: 135e9fd5a910bf450812fa8406b25579857bcd320c93ea6b6660ce4242376650
+  metadata.gz: 579403fba577dd83ce26ad13d8893ccdf86bc28883fff397fc029f265f0b7cd5
+  data.tar.gz: '08435986fca6664001ebb07dcd1b49a79a116b6cd78f26638a3c0a5d37e9c7b3'
 SHA512:
-  metadata.gz: 1cb7e169a1dd94f2c081e75147a467984d1e9d0457ca0337b44a8b6cfd4db5e6217a1d41261f52f7a81ed1f9dbcfa837a7ef1d9a4498d694472e4df43289f321
-  data.tar.gz: e238bdd98f374db76e6363b46abd0b8ea2269723d780e30e8150fbb9aca958410fb759f12148abae4ffd418323fa58005b6229ed063db1bbbe02d59cd916e9e0
+  metadata.gz: 936274740450e2cbaf08f7f060df37f3a5a29e4aea47bc9985028403f2aca0f879f724167861e1b444f829b597682f2786dd2bf31f00b5ef5a26002ddda094d8
+  data.tar.gz: a59847233f9e50690fad84ed1cb071b204effe830f00bf738a08b2f7208211cd38d79e4b5504d1408c63dba930da4f87db31d0eb1d75c860b0dc1e2bc3bb53a9

data/CHANGE_LOG.md

@@ -4,6 +4,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 2.0.2
+
+### Changed
+
+- An `ArgumentError` is now raised when a named encrypted argument cannot be matched to a parameter of the worker's `perform` method or when the worker class name cannot be resolved to a class. Previously these arguments were silently left unencrypted.
+
+### Fixed
+
+- Setting the secret to an empty value (e.g. an empty array or empty string) no longer silently disables encryption. An `InvalidSecretError` is now raised when encrypting or decrypting if no secret is available.
+- The client middleware no longer mutates the caller's arguments array in place when encrypting arguments.
+- Lazily initializing the encryption keys from the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable is now thread safe.
+
+## 2.0.1
+
+### Added
+
+- Added initializer helper methods `Sidekiq::EncryptedArgs.encrypt_before` and `Sidekiq::EncryptedArgs.encrypt_after` to allow specifying middleware order for inserting the client encryption middleware and `Sidekiq::EncryptedArgs.decrypt_before` and `Sidekiq::EncryptedArgs.decrypt_after` to allow specifying middleware order for inserting the server decryption middleware.
+
+## 2.0.0
+
+### Changed
+
+- A secret key is now required to be set. Previously the code would silently fail if no key was set. This change improves security by protecting against misconfiguration leaking data into Redis.
+- Bumped minimum required Ruby version to 2.7 and Sidekiq to 6.3.
+
 ## 1.2.0
 
 ### Removed

data/README.md

@@ -22,7 +22,7 @@ To use the gem, you will need to specify a secret that will be used to encrypt t
 Sidekiq::EncryptedArgs.configure!(secret: "YourSecretKey")
 ```
 
-If the secret is not set, the value of the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable will be used as the secret. If this variable is not set, job arguments will not be encrypted.
+If the secret is not set explicitly, the value of the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable will be used as the secret. If you call `configure!` without setting a secret (either explicitly or via the environment variable), an error will be raised.
 
 The call to `Sidekiq::EncryptedArgs.configure!` will **prepend** the client encryption middleware and **append** server decryption middleware. By doing this, any other middleware you register will only receive the encrypted parameters (e.g. logging middleware will receive the encrypted parameters).
 
@@ -42,7 +42,8 @@ Sidekiq.configure_server do |config|
     chain.add Sidekiq::EncryptedArgs::ServerMiddleware
   end
 
-  # register client middleware on the server so that starting jobs in a Sidekiq::Worker also get encrypted args
+  # Register client middleware on the server so that starting jobs from within
+  # another also get encrypted args.
   # https://github.com/mperham/sidekiq/wiki/Middleware#client-middleware-registered-in-both-places
   config.client_middleware do |chain|
     chain.prepend Sidekiq::EncryptedArgs::ClientMiddleware
@@ -50,6 +51,15 @@ Sidekiq.configure_server do |config|
 end
 ```
 
+If there is specific middleware you want to insert the encryption or decryption middleware before or after, you can use the following helper methods:
+
+```ruby
+Sidekiq::EncryptedArgs.encrypt_before(SomeOtherMiddlewareClass)
+Sidekiq::EncryptedArgs.encrypt_after(SomeOtherMiddlewareClass)
+Sidekiq::EncryptedArgs.decrypt_before(SomeOtherMiddlewareClass)
+Sidekiq::EncryptedArgs.decrypt_after(SomeOtherMiddlewareClass)
+```
+
 ## Worker Configuration
 
 To declare that a worker is using encrypted arguments, you must set the `encrypted_args` sidekiq option.
@@ -58,7 +68,7 @@ Setting the option to `true` will encrypt all the arguments passed to the `perfo
 
 ```ruby
 class SecretWorker
-  include Sidekiq::Worker
+  include Sidekiq::Job
 
   sidekiq_options encrypted_args: true
 
@@ -67,20 +77,24 @@ class SecretWorker
 end
 ```
 
-You can also choose to only encrypt specific arguments with an array of either argument names (symbols or strings) or indexes. This is useful to preserve visibility into non-sensitive arguments for troubleshooting or other reasons. Both of these examples encrypt just the second argument to the `perform` method.
+You can also choose to only encrypt specific arguments by specifying either argument names (as symbols or strings) or argument positions (as integers). This is useful to preserve visibility into non-sensitive arguments for troubleshooting or other reasons. All of these examples encrypt just the second argument to the `perform` method.
 
 ```ruby
-# Pass in a list of argument names that should be encrypted
+# Pass in a single argument name
+sidekiq_options encrypted_args: :arg_2
+# or as a string
+sidekiq_options encrypted_args: "arg_2"
+# or as an array
 sidekiq_options encrypted_args: [:arg_2]
-# or
-sidekiq_options encrypted_args: ["arg_2"]
 
 def perform(arg_1, arg_2, arg_3)
 end
 ```
 
 ```ruby
-# Pass in an array of integers indicating which argument positions should be encrypted
+# Pass in an integer indicating which argument position should be encrypted (0-indexed)
+sidekiq_options encrypted_args: 1
+# or as an array
 sidekiq_options encrypted_args: [1]
 
 def perform(arg_1, arg_2, arg_3)
@@ -99,7 +113,7 @@ Sidekiq::EncryptedArgs.secret = ["CurrentSecret", "OldSecret", "EvenOlderSecret"
 
 The first (left most) key will be considered the current key, and is used for encrypting arguments. When decrypting, we iterate over the secrets list until we find the correct one. This allows you to switch you secret keys without breaking jobs already enqueued in Redis.
 
-If you are using the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable to specify your secret, you can delimit multiple keys with a spaces.
+If you are using the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable to specify your secret, you can separate multiple keys with whitespace (spaces or tabs).
 
 You can also safely add encryption to an existing worker. Any jobs that are already enqueued will still run even without having the arguments encrypted in Redis.
 

data/VERSION

@@ -1 +1 @@
-1.2.0
+2.0.2

data/lib/sidekiq/encrypted_args/client_middleware.rb

@@ -10,7 +10,16 @@ module Sidekiq
     #
     # @see ServerMiddleware
     class ClientMiddleware
-      # Encrypt specified arguments before they're sent off to the queue
+      include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+      # Encrypt specified arguments before they're sent off to the queue.
+      #
+      # @param [String, Class] worker_class The worker class or class name
+      # @param [Hash] job The Sidekiq job hash containing arguments and metadata
+      # @param [String] queue The name of the queue
+      # @param [Object, nil] redis_pool Optional Redis connection pool (legacy parameter)
+      # @return [void]
+      # @yield Passes control to the next middleware in the chain
       def call(worker_class, job, queue, redis_pool = nil)
         if job.include?("encrypted_args")
           encrypted_args = EncryptedArgs.encrypted_args_option(worker_class, job)
@@ -26,15 +35,19 @@ module Sidekiq
       #
       # Additionally, set `job["encrypted_args"]` to the canonicalized version (i.e. `Array<Integer>`)
       #
+      # The args array is replaced rather than mutated in place since the array
+      # can be the same object passed in by the caller of Sidekiq::Client.push.
+      #
       # @param [Hash] job The Sidekiq job hash containing arguments and metadata
       # @param [Array<Integer>] encrypted_args array of indexes in job to encrypt
       # @return [void]
       def encrypt_job_arguments!(job, encrypted_args)
         if encrypted_args
-          job_args = job["args"]
-          job_args.each_with_index do |value, position|
+          job["args"] = job["args"].map.with_index do |value, position|
             if encrypted_args.include?(position) && !EncryptedArgs.encrypted?(value)
-              job_args[position] = EncryptedArgs.encrypt(value)
+              EncryptedArgs.encrypt(value)
+            else
+              value
             end
           end
           job["encrypted_args"] = encrypted_args

data/lib/sidekiq/encrypted_args/server_middleware.rb

@@ -10,11 +10,20 @@ module Sidekiq
     #
     # @see ClientMiddleware
     class ServerMiddleware
-      # Wrap the server process to decrypt incoming arguments
+      include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+      # Wrap the server process to decrypt incoming arguments.
+      #
+      # @param [Object] worker The worker instance that will process the job
+      # @param [Hash] job The Sidekiq job hash containing arguments and metadata
+      # @param [String] queue The name of the queue
+      # @return [void]
+      # @yield Passes control to the worker's perform method
       def call(worker, job, queue)
         encrypted_args = job["encrypted_args"]
+
         if encrypted_args
-          encrypted_args = backward_compatible_encrypted_args(encrypted_args, worker.class, job)
+          encrypted_args = EncryptedArgs.encrypted_args_option(worker.class, job)
           job_args = job["args"]
           encrypted_args.each do |position|
             value = job_args[position]
@@ -24,17 +33,6 @@ module Sidekiq
 
         yield
       end
-
-      private
-
-      # Ensure that the encrypted args is an array of integers. If not re-read it from the class
-      # definition since gem version 1.0.2 and earlier did not update the encrypted_args on the job.
-      def backward_compatible_encrypted_args(encrypted_args, worker_class, job)
-        unless encrypted_args.is_a?(Array) && encrypted_args.all? { |position| position.is_a?(Integer) }
-          encrypted_args = EncryptedArgs.encrypted_args_option(worker_class, job)
-        end
-        encrypted_args
-      end
     end
   end
 end

data/lib/sidekiq/encrypted_args/version.rb

@@ -2,6 +2,7 @@
 
 module Sidekiq
   module EncryptedArgs
+    # The current version of the sidekiq-encrypted_args gem.
     VERSION = File.read(File.join(__dir__, "..", "..", "..", "VERSION")).chomp.freeze
   end
 end

data/lib/sidekiq/encrypted_args.rb

@@ -11,17 +11,18 @@ module Sidekiq
   # in Redis to protect sensitive information like API keys, passwords, or
   # personally identifiable information.
   module EncryptedArgs
+    @encryptors = nil
+    @mutex = Mutex.new
+
     # Error thrown when the secret is invalid
     class InvalidSecretError < StandardError
-      def initialize
-        super("Cannot decrypt. Invalid secret provided.")
-      end
     end
 
     class << self
       # Set the secret key used for encrypting arguments. If this is not set,
       # the value will be loaded from the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment
-      # variable. If that value is not set, arguments will not be encrypted.
+      # variable. If that value is not set either, an InvalidSecretError will be
+      # raised when arguments are encrypted or decrypted.
       #
       # You can set multiple secrets by passing an array if you need to roll your secrets.
       # The left most value in the array will be used as the encryption secret, but
@@ -39,7 +40,9 @@ module Sidekiq
       # @param [String, Array<String>] value One or more secrets to use for encrypting arguments.
       # @return [void]
       def secret=(value)
-        @encryptors = make_encryptors(value)
+        @mutex.synchronize do
+          @encryptors = make_encryptors(value).freeze
+        end
       end
 
       # Add the client and server middleware to the default Sidekiq
@@ -58,6 +61,7 @@ module Sidekiq
       # @param [String] secret optionally set the secret here. See {.secret=}
       def configure!(secret: nil)
         self.secret = secret unless secret.nil?
+        encryptors # Calling encryptors will validate that a secret is set.
 
         Sidekiq.configure_client do |config|
           config.client_middleware do |chain|
@@ -75,6 +79,66 @@ module Sidekiq
         end
       end
 
+      # Insert the client encryption middleware before the specified middleware.
+      #
+      # @param [Class] middleware The middleware class to insert before
+      # @return [void]
+      def encrypt_before(middleware)
+        Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.insert_before(middleware, Sidekiq::EncryptedArgs::ClientMiddleware)
+          end
+        end
+
+        Sidekiq.configure_server do |config|
+          config.client_middleware do |chain|
+            chain.insert_before(middleware, Sidekiq::EncryptedArgs::ClientMiddleware)
+          end
+        end
+      end
+
+      # Insert the client encryption middleware after the specified middleware.
+      #
+      # @param [Class] middleware The middleware class to insert after
+      # @return [void]
+      def encrypt_after(middleware)
+        Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.insert_after(middleware, Sidekiq::EncryptedArgs::ClientMiddleware)
+          end
+        end
+
+        Sidekiq.configure_server do |config|
+          config.client_middleware do |chain|
+            chain.insert_after(middleware, Sidekiq::EncryptedArgs::ClientMiddleware)
+          end
+        end
+      end
+
+      # Insert the server decryption middleware before the specified middleware.
+      #
+      # @param [Class] middleware The middleware class to insert before
+      # @return [void]
+      def decrypt_before(middleware)
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.insert_before(middleware, Sidekiq::EncryptedArgs::ServerMiddleware)
+          end
+        end
+      end
+
+      # Insert the server decryption middleware after the specified middleware.
+      #
+      # @param [Class] middleware The middleware class to insert after
+      # @return [void]
+      def decrypt_after(middleware)
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.insert_after(middleware, Sidekiq::EncryptedArgs::ServerMiddleware)
+          end
+        end
+      end
+
       # Encrypt a value.
       #
       # @example Encrypting a simple value
@@ -85,17 +149,12 @@ module Sidekiq
       #
       # @param [#to_json, Object] data Data to encrypt. You can pass any JSON compatible data types or structures.
       #
-      # @return [String]
+      # @return [String, nil]
       def encrypt(data)
         return nil if data.nil?
 
         json = (data.respond_to?(:to_json) ? data.to_json : JSON.generate(data))
-        encrypted = encrypt_string(json)
-        if encrypted == json
-          data
-        else
-          encrypted
-        end
+        encrypt_string(json)
       end
 
       # Decrypt data
@@ -127,7 +186,10 @@ module Sidekiq
       # can be `true` or an array indicating if each positional argument should be encrypted, or a hash
       # with keys for the argument position and true as the value.
       #
-      # @private
+      # @param [String, Class] worker_class The worker class or class name
+      # @param [Hash] job The Sidekiq job hash containing arguments and metadata
+      # @return [Array<Integer>, nil] Array of argument positions to encrypt, or nil if encryption is not configured
+      # @api private
       def encrypted_args_option(worker_class, job)
         option = job["encrypted_args"]
         return nil if option.nil?
@@ -140,21 +202,30 @@ module Sidekiq
           raise ArgumentError.new("Hash-based argument encryption is no longer supported.")
         else
           array_type = nil
-          Array(option).each_with_index do |val, position|
+          Array(option).each do |val|
             current_type = nil
             if val.is_a?(Integer)
               indexes << val
               current_type = :integer
             elsif val.is_a?(Symbol) || val.is_a?(String)
-              worker_class = constantize(worker_class) if worker_class.is_a?(String)
+              if worker_class.is_a?(String)
+                class_name = worker_class
+                worker_class = constantize(worker_class)
+                if worker_class.nil?
+                  raise ArgumentError.new("Cannot resolve worker class #{class_name.inspect} to look up named encrypted args; use integer positions instead.")
+                end
+              end
               position = perform_method_parameter_index(worker_class, val)
-              indexes << position if position
+              if position.nil?
+                raise ArgumentError.new("Encrypted arg #{val.inspect} is not a parameter of #{worker_class}#perform.")
+              end
+              indexes << position
               current_type = :symbol
             else
               raise ArgumentError.new("Encrypted args must be specified as integers or symbols.")
             end
 
-            if array_type && current_type
+            if array_type && current_type != array_type
               raise ArgumentError.new("Encrypted args cannot mix integers and symbols.")
             else
               array_type ||= current_type
@@ -171,36 +242,52 @@ module Sidekiq
       private_constant :SALT
 
       def encrypt_string(value)
-        encryptor = encryptors.first
-        return value if encryptor.nil?
-        encryptor.encrypt(value)
+        encryptors.first.encrypt(value)
       end
 
       def decrypt_string(value)
-        return value if encryptors == [nil]
         encryptors.each do |encryptor|
-          begin
-            return encryptor.decrypt(value) if encryptor
-          rescue OpenSSL::Cipher::CipherError
-            # Not the right key, try the next one
-          end
+          return encryptor.decrypt(value)
+        rescue OpenSSL::Cipher::CipherError
+          # Not the right key, try the next one
         end
-        raise InvalidSecretError
+
+        # None of the keys worked
+        raise InvalidSecretError.new("Cannot decrypt. Invalid secret provided.")
       end
 
       def encryptors
-        if !defined?(@encryptors) || @encryptors.empty?
-          @encryptors = make_encryptors(ENV["SIDEKIQ_ENCRYPTED_ARGS_SECRET"].to_s.split)
+        current = @encryptors
+        return current unless current.nil?
+
+        @mutex.synchronize do
+          if @encryptors.nil?
+            secret = ENV.fetch("SIDEKIQ_ENCRYPTED_ARGS_SECRET", "").strip
+            if secret.empty?
+              raise InvalidSecretError.new("Secret not set. Call Sidekiq::EncryptedArgs.secret= or set the SIDEKIQ_ENCRYPTED_ARGS_SECRET environment variable.")
+            end
+
+            @encryptors = make_encryptors(secret.split).freeze
+          end
+          @encryptors
         end
-        @encryptors
       end
 
+      # Create encryptors from secrets.
+      #
+      # @param [String, Array<String>] secrets One or more secrets to create encryptors from
+      # @return [Array<SecretKeys::Encryptor>, nil] Array of encryptors or nil if no secrets provided
       def make_encryptors(secrets)
-        Array(secrets).map { |val| val.nil? ? nil : SecretKeys::Encryptor.from_password(val, SALT) }
+        secrets = Array(secrets).reject { |val| val.nil? || val.to_s.empty? }
+        return nil if secrets.empty?
+
+        secrets.map { |val| SecretKeys::Encryptor.from_password(val, SALT) }
       end
 
-      # @param [String] class_name name of a class
-      # @return [Class] class that was referenced by name
+      # Convert a string class name into the actual class constant.
+      #
+      # @param [String] class_name Name of a class (e.g., "MyModule::MyClass")
+      # @return [Class, nil] The class constant that was referenced by name, or nil if it is not defined
       def constantize(class_name)
         names = class_name.split("::")
         # Clear leading :: for root namespace since we're already calling from object
@@ -208,28 +295,27 @@ module Sidekiq
         # Map reduce to the constant. Use inherit=false to not accidentally search
         # parent modules
         names.inject(Object) { |constant, name| constant.const_get(name, false) }
+      rescue NameError
+        nil
       end
 
-      def replace_argument_positions(worker_class, encrypt_option_hash)
-        encrypted_indexes = []
-        encrypt_option_hash.each do |key, value|
-          next unless value
+      # Get the index of a parameter in the worker's perform method.
+      #
+      # @param [Class] worker_class The worker class to inspect
+      # @param [String, Symbol] parameter The parameter name to find
+      # @return [Integer, nil] The zero-based index of the parameter, or nil if not found
+      def perform_method_parameter_index(worker_class, parameter)
+        return nil unless worker_class
 
-          if key.is_a?(Integer) || (key.is_a?(String) && key.match?(INTEGER_PATTERN))
-            encrypted_indexes << key.to_i
-          elsif key.is_a?(Symbol) || key.is_a?(String)
-            position = perform_method_parameter_index(worker_class, key)
-            encrypted_indexes << position if position
-          end
+        perform_method = begin
+          worker_class.instance_method(:perform)
+        rescue NameError
+          nil
         end
-        encrypted_indexes
-      end
+        return nil if perform_method.nil?
 
-      def perform_method_parameter_index(worker_class, parameter)
-        if worker_class
-          parameter = parameter.to_sym
-          worker_class.instance_method(:perform).parameters.find_index { |_, name| name == parameter }
-        end
+        parameter = parameter.to_sym
+        perform_method.parameters.find_index { |_, name| name == parameter }
       end
     end
   end

data/sidekiq-encrypted_args.gemspec

@@ -18,9 +18,11 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
     .
+    benchmark.rb
     Appraisals
     Gemfile
     Gemfile.lock
+    benchmark.rb
     Rakefile
     gemfiles/
     spec/
@@ -33,10 +35,8 @@ Gem::Specification.new do |spec|
   spec.bindir = "bin"
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 
-  spec.required_ruby_version = ">= 2.4"
+  spec.required_ruby_version = ">= 2.7"
 
-  spec.add_dependency "sidekiq", ">= 4.0"
+  spec.add_dependency "sidekiq", ">= 6.3"
   spec.add_dependency "secret_keys"
-
-  spec.add_development_dependency "bundler", "~>2.0"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-encrypted_args
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Brian Durand
 - Winston Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -17,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.3'
 - !ruby/object:Gem::Dependency
   name: secret_keys
   requirement: !ruby/object:Gem::Requirement
@@ -39,21 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-description:
 email:
 - bbdurand@gmail.com
 - me@winstondurand.com
@@ -65,7 +49,6 @@ files:
 - MIT_LICENSE.txt
 - README.md
 - VERSION
-- benchmark.rb
 - lib/sidekiq-encrypted_args.rb
 - lib/sidekiq/encrypted_args.rb
 - lib/sidekiq/encrypted_args/client_middleware.rb
@@ -79,7 +62,6 @@ metadata:
   homepage_uri: https://github.com/bdurand/sidekiq-encrypted_args
   source_code_uri: https://github.com/bdurand/sidekiq-encrypted_args
   changelog_uri: https://github.com/bdurand/sidekiq-encrypted_args/blob/main/CHANGE_LOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -87,15 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Support for encrypting arguments that contain sensitive information in sidekiq
   jobs.

data/benchmark.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-
-require "benchmark"
-require "sidekiq"
-require_relative "lib/sidekiq/encrypted_args"
-
-class WorkerWithoutEncryption
-  include Sidekiq::Worker
-
-  def perform(arg_1, arg_2, arg_3)
-  end
-end
-
-class WorkerWithEncryption
-  include Sidekiq::Worker
-
-  sidekiq_options encrypted_args: [true, true, true]
-
-  def perform(arg_1, arg_2, arg_3)
-  end
-end
-
-middleware = ->(worker_class) {
-  job = {"args" => ["foo", "bar", "baz"]}
-  Sidekiq::EncryptedArgs::ClientMiddleware.new.call(worker_class, job, "default") do
-    worker = worker_class.new
-    Sidekiq::EncryptedArgs::ServerMiddleware.new.call(worker, job, "default") do
-      worker.perform(*job["args"])
-    end
-  end
-}
-
-Benchmark.bm do |benchmark|
-  benchmark.report("No Encryption:  ") { 10000.times { middleware.call(WorkerWithoutEncryption) } }
-  benchmark.report("With Encryption:") { 10000.times { middleware.call(WorkerWithEncryption) } }
-end