datadog 2.38.0 → 2.47.0

data/lib/datadog/core/telemetry/transport/http.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../encoding'
-require_relative '../../transport/http'
-require_relative 'telemetry'
+require_relative "../../encoding"
+require_relative "../../transport/http"
+require_relative "telemetry"
 
 module Datadog
   module Core
@@ -11,12 +11,12 @@ module Datadog
         # Namespace for HTTP transport components
         module HTTP
           AGENT_TELEMETRY = Telemetry::API::Endpoint.new(
-            '/telemetry/proxy/api/v2/apmtelemetry',
+            "/telemetry/proxy/api/v2/apmtelemetry",
             Core::Encoding::JSONEncoder,
           )
 
           AGENTLESS_TELEMETRY = Telemetry::API::Endpoint.new(
-            '/api/v2/apmtelemetry',
+            "/api/v2/apmtelemetry",
             Core::Encoding::JSONEncoder,
           )
 
@@ -35,7 +35,7 @@ module Datadog
               agent_settings: agent_settings,
               headers: headers
             ) do |transport|
-              transport.api 'agentless_telemetry', AGENTLESS_TELEMETRY
+              transport.api "agentless_telemetry", AGENTLESS_TELEMETRY
               # Call block to apply any customization, if provided
               yield(transport) if block_given?
             end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
@@ -55,7 +55,7 @@ module Datadog
               agent_settings: agent_settings,
               headers: headers
             ) do |transport|
-              transport.api 'agent_telemetry', AGENT_TELEMETRY
+              transport.api "agent_telemetry", AGENT_TELEMETRY
 
               # Call block to apply any customization, if provided
               yield(transport) if block_given?

data/lib/datadog/core/telemetry/transport/telemetry.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../transport/parcel'
-require_relative '../../transport/transport'
-require_relative 'http/telemetry'
+require_relative "../../transport/parcel"
+require_relative "../../transport/transport"
+require_relative "http/telemetry"
 
 module Datadog
   module Core

data/lib/datadog/core/telemetry/worker.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'event'
+require_relative "event"
 
-require_relative '../utils/only_once_successful'
-require_relative '../workers/polling'
-require_relative '../workers/queue'
+require_relative "../utils/only_once_successful"
+require_relative "../workers/polling"
+require_relative "../workers/queue"
 
 module Datadog
   module Core
@@ -239,7 +239,7 @@ module Datadog
         end
 
         def buffer_klass
-          if Core::Environment::Ext::RUBY_ENGINE == 'ruby'
+          if Core::Environment::Ext::RUBY_ENGINE == "ruby"
             Core::Buffer::CRuby
           else
             Core::Buffer::ThreadSafe
@@ -254,7 +254,7 @@ module Datadog
         def disable_on_not_found!(response)
           return unless response.not_found?
 
-          logger.debug('Agent does not support telemetry; disabling future telemetry events.')
+          logger.debug("Agent does not support telemetry; disabling future telemetry events.")
           disable!
         end
 

data/lib/datadog/core/transport/ext.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-require_relative '../configuration/ext'
+require_relative "../configuration/ext"
 module Datadog
   module Core
     module Transport
       # @public_api
       module Ext
         module HTTP
-          HEADER_CONTAINER_ID = 'Datadog-Container-ID'
-          HEADER_CONTAINER_TAGS_HASH = 'Datadog-Container-Tags-Hash'
-          HEADER_ENTITY_ID = 'Datadog-Entity-ID'
-          HEADER_EXTERNAL_ENV = 'Datadog-External-Env'
-          HEADER_DD_API_KEY = 'DD-API-KEY'
+          HEADER_CONTAINER_ID = "Datadog-Container-ID"
+          HEADER_CONTAINER_TAGS_HASH = "Datadog-Container-Tags-Hash"
+          HEADER_ENTITY_ID = "Datadog-Entity-ID"
+          HEADER_EXTERNAL_ENV = "Datadog-External-Env"
+          HEADER_DD_API_KEY = "DD-API-KEY"
           # Tells agent that `_dd.top_level` metrics have been set by the tracer.
           # The agent will not calculate top-level spans but instead trust the tracer tagging.
           #
           # This prevents partially flushed traces being mistakenly marked as top-level.
           #
           # Setting this header to any non-empty value enables this feature.
-          HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'
-          HEADER_CLIENT_COMPUTED_STATS = 'Datadog-Client-Computed-Stats'
-          HEADER_META_LANG = 'Datadog-Meta-Lang'
-          HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'
-          HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'
+          HEADER_CLIENT_COMPUTED_TOP_LEVEL = "Datadog-Client-Computed-Top-Level"
+          HEADER_CLIENT_COMPUTED_STATS = "Datadog-Client-Computed-Stats"
+          HEADER_META_LANG = "Datadog-Meta-Lang"
+          HEADER_META_LANG_VERSION = "Datadog-Meta-Lang-Version"
+          HEADER_META_LANG_INTERPRETER = "Datadog-Meta-Lang-Interpreter"
           # Use for distinguishing between CRuby, JRuby, and TruffleRuby.
-          HEADER_META_LANG_INTERPRETER_VENDOR = 'Datadog-Meta-Lang-Interpreter-Vendor'
-          HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'
+          HEADER_META_LANG_INTERPRETER_VENDOR = "Datadog-Meta-Lang-Interpreter-Vendor"
+          HEADER_META_TRACER_VERSION = "Datadog-Meta-Tracer-Version"
 
           # Header that prevents the Net::HTTP integration from tracing internal trace requests.
           # Set it to any value to skip tracing.
-          HEADER_DD_INTERNAL_UNTRACED_REQUEST = 'DD-Internal-Untraced-Request'
+          HEADER_DD_INTERNAL_UNTRACED_REQUEST = "DD-Internal-Untraced-Request"
         end
 
         module Test

data/lib/datadog/core/transport/http/adapters/net.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../../../core/transport/response'
-require_relative '../../../../core/vendor/multipart-post/net/http/post/multipart'
+require_relative "../../../../core/transport/response"
+require_relative "../../../../core/vendor/multipart-post/net/http/post/multipart"
 
 module Datadog
   module Core
@@ -90,9 +90,9 @@ module Datadog
               path = env.path
               case query = env.query
               when Hash
-                path = path + '?' + URI.encode_www_form(query)
+                path = path + "?" + URI.encode_www_form(query)
               when String
-                path = path + '?' + query
+                path = path + "?" + query
               when nil
                 # Nothing
               else

data/lib/datadog/core/transport/http/adapters/test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../../core/transport/response'
+require_relative "../../../../core/transport/response"
 
 module Datadog
   module Core

data/lib/datadog/core/transport/http/adapters/unix_socket.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require_relative '../../../transport/ext'
-require_relative 'net'
+require "net/http"
+require_relative "../../../transport/ext"
+require_relative "net"
 
 module Datadog
   module Core
@@ -58,7 +58,7 @@ module Datadog
               alias_method :uds_path, :filepath
 
               def initialize(uds_path, options = {})
-                super('localhost', 80)
+                super("localhost", 80)
                 @filepath = uds_path
                 @read_timeout = options.fetch(:read_timeout, DEFAULT_TIMEOUT)
                 @continue_timeout = options.fetch(:continue_timeout, DEFAULT_TIMEOUT)

data/lib/datadog/core/transport/http/api/endpoint.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Datadog
   module Core

data/lib/datadog/core/transport/http/api/map.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'fallbacks'
+require_relative "fallbacks"
 
 module Datadog
   module Core

data/lib/datadog/core/transport/http/builder.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings'
-require_relative 'adapters/registry'
-require_relative 'api/map'
+require_relative "../../configuration/agent_settings"
+require_relative "adapters/registry"
+require_relative "api/map"
 
 module Datadog
   module Core
@@ -171,14 +171,14 @@ module Datadog
           # Raised when built without defining APIs.
           class NoApisError < StandardError
             def message
-              'No APIs configured for transport!'
+              "No APIs configured for transport!"
             end
           end
 
           # Raised when client built without defining a default API.
           class NoDefaultApiError < StandardError
             def message
-              'No default API configured for transport!'
+              "No default API configured for transport!"
             end
           end
         end

data/lib/datadog/core/transport/http/client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'env'
-require_relative '../response'
+require_relative "env"
+require_relative "../response"
 
 module Datadog
   module Core

data/lib/datadog/core/transport/http/response.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/response'
+require_relative "../../../core/transport/response"
 
 module Datadog
   module Core

data/lib/datadog/core/transport/http.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'http/builder'
-require_relative 'http/adapters/net'
-require_relative 'http/adapters/unix_socket'
-require_relative 'http/adapters/test'
-require_relative '../environment/container'
-require_relative '../environment/ext'
+require_relative "http/builder"
+require_relative "http/adapters/net"
+require_relative "http/adapters/unix_socket"
+require_relative "http/adapters/test"
+require_relative "../environment/container"
+require_relative "../environment/ext"
 
 module Datadog
   module Core
@@ -51,7 +51,7 @@ module Datadog
 
         def default_headers
           {
-            Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => "1",
             Core::Transport::Ext::HTTP::HEADER_META_LANG =>
               Datadog::Core::Environment::Ext::LANG,
             Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION =>
@@ -61,7 +61,7 @@ module Datadog
             Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR =>
               Core::Environment::Ext::LANG_ENGINE,
             Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
-              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
+              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION,
           }.tap do |headers|
             # Add application container info
             headers.merge!(Core::Environment::Container.to_headers)
@@ -70,7 +70,7 @@ module Datadog
             unless Datadog.configuration.apm.tracing.enabled
               # Sending this header to the agent will disable metrics computation (and billing) on the agent side
               # by pretending it has already been done on the library side.
-              headers[Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+              headers[Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = "yes"
             end
           end
         end

data/lib/datadog/core/transport/transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'http/client'
+require_relative "http/client"
 
 module Datadog
   module Core
@@ -69,7 +69,7 @@ module Datadog
 
           @current_api_id = api_id
           client_class = self.class.http_client_class || Core::Transport::HTTP::Client
-          @client = client_class.new(current_api, logger: logger) # steep:ignore
+          @client = client_class.new(current_api, logger: logger)
         end
 
         def downgrade?(response)

data/lib/datadog/core/utils/at_fork_monkey_patch.rb

@@ -6,8 +6,30 @@ module Datadog
       # Monkey patches `Kernel#fork` and similar functions, adding an `at_fork` callback mechanism which
       # is used to restart observability after the VM forks (e.g. in multiprocess Ruby apps).
       module AtForkMonkeyPatch
-        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
-        private_constant :AT_FORK_CHILD_BLOCKS
+        class Callback
+          attr_reader :block, :group
+
+          def initialize(block, group = nil)
+            @block = block
+            @group = group
+            freeze
+          end
+        end
+        private_constant :Callback
+
+        EMPTY_AT_FORK_BLOCKS = {
+          before: [].freeze,
+          parent: [].freeze,
+          child: [].freeze,
+        }.freeze
+        private_constant :EMPTY_AT_FORK_BLOCKS
+
+        @at_fork_blocks = EMPTY_AT_FORK_BLOCKS
+
+        # Serializes copy-on-write registry updates. Fork dispatch only reads the
+        # latest immutable registry reference and never acquires this mutex.
+        AT_FORK_REGISTRY_MUTEX = Mutex.new
+        private_constant :AT_FORK_REGISTRY_MUTEX
 
         def self.supported?
           Process.respond_to?(:fork)
@@ -16,7 +38,7 @@ module Datadog
         def self.apply!
           return false unless supported?
 
-          if RubyVersion.is?('< 3.1')
+          if RubyVersion.is?("< 3.1")
             [
               ::Process.singleton_class, # Process.fork
               ::Kernel.singleton_class,  # Kernel.fork
@@ -31,43 +53,147 @@ module Datadog
           true
         end
 
-        def self.run_at_fork_blocks(stage)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
+        # Runs the callbacks copied for one fork lifecycle. Before callbacks
+        # stop at the first failure; parent and child callbacks all run before
+        # the first failure is re-raised.
+        def self.run_at_fork_blocks(stage, snapshot:, started: nil)
+          callbacks = blocks_for(snapshot, stage)
+          if stage == :before
+            return callbacks.each do |callback|
+              started[callback.group] = true if started && callback.group
+              callback.block.call
+            end
+          end
+
+          error = nil
+          callbacks.each do |callback|
+            next if started && callback.group && !started.key?(callback.group)
 
-          AT_FORK_CHILD_BLOCKS.each(&:call)
+            callback.block.call
+          rescue Exception => e # rubocop:disable Lint/RescueException -- finish cleanup, then re-raise the first failure
+            error ||= e
+          end
+          raise error if error
         end
 
+        def self.run_parent_cleanup(snapshot, started, fork_error)
+          run_at_fork_blocks(:parent, snapshot: snapshot, started: started)
+        rescue Exception => cleanup_error # rubocop:disable Lint/RescueException -- preserve the original fork failure
+          Datadog.logger.warn do
+            "Parent at-fork cleanup failed while handling #{fork_error.class}: " \
+              "#{cleanup_error.class}: #{cleanup_error.message}"
+          end
+        end
+        private_class_method :run_parent_cleanup
+
+        # Registers a block to run at the given fork +stage+ (+:before+,
+        # +:parent+, or +:child+).
+        #
+        # Returns the registered block so callers can keep a handle to it and
+        # later deregister it via {.remove_at_fork}.
         def self.at_fork(stage, &block)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
-          raise(ArgumentError, 'Missing block argument') unless block
+          raise(ArgumentError, "Missing block argument") unless block
 
-          AT_FORK_CHILD_BLOCKS << block
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = current.merge(
+              stage => (blocks_for(current, stage) + [Callback.new(block)]).freeze
+            ).freeze
+          end
 
-          true
+          block
+        end
+
+        # Registers one before/parent/child callback triplet atomically relative
+        # to the snapshots taken by fork dispatch.
+        def self.at_fork_blocks(before:, parent:, child:)
+          blocks = {before: before, parent: parent, child: child}
+          group = Object.new.freeze
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = {
+              before: (current.fetch(:before) + [Callback.new(before, group)]).freeze,
+              parent: (current.fetch(:parent) + [Callback.new(parent, group)]).freeze,
+              child: (current.fetch(:child) + [Callback.new(child, group)]).freeze,
+            }.freeze
+          end
+          blocks
         end
 
+        # Deregisters a block previously registered with {.at_fork} for the given
+        # +stage+. It is a no-op (does not raise) when +block+ was never
+        # registered (or was already removed). Raises +ArgumentError+ for an
+        # unknown stage, matching the {.at_fork} contract.
+        def self.remove_at_fork(stage, block)
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            callbacks = blocks_for(current, stage)
+            @at_fork_blocks = current.merge(
+              stage => callbacks.reject { |callback| callback.block.equal?(block) }.freeze
+            ).freeze
+          end
+
+          nil
+        end
+
+        # Returns the immutable callback registry for one fork lifecycle.
+        # Copy-on-write updates publish a new reference, so registrations made
+        # afterwards apply only to the next lifecycle without locking this read.
+        def self.snapshot_at_fork_blocks
+          @at_fork_blocks
+        end
+
+        def self.replace_at_fork_blocks(snapshot)
+          AT_FORK_REGISTRY_MUTEX.synchronize { @at_fork_blocks = snapshot }
+        end
+        private_class_method :replace_at_fork_blocks
+
+        def self.blocks_for(snapshot, stage)
+          case stage
+          when :before, :parent, :child then snapshot.fetch(stage)
+          else raise(ArgumentError, "Unsupported stage #{stage}")
+          end
+        end
+        private_class_method :blocks_for
+
         # Adds `at_fork` behavior; see parent module for details.
         module KernelMonkeyPatch
           def fork
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+
             # If a block is provided, it must be wrapped to trigger callbacks.
             child_block = if block_given?
               proc do
-                AtForkMonkeyPatch.run_at_fork_blocks(:child)
+                AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
 
                 # Invoke original block
                 yield
               end
             end
 
-            # Start fork
-            # If a block is provided, use the wrapped version.
-            result = child_block.nil? ? super : super(&child_block)
+            begin
+              # Run pre-fork callbacks in the parent, just before forking.
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+
+              # Start fork. If a block is provided, use the wrapped version.
+              result = child_block.nil? ? super : super(&child_block)
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed and we are still in
+              # the parent. Restore any state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
             # When fork gets called without a block, it returns twice:
             # If we're in the fork, result = nil: trigger child callbacks.
-            # If we're in the parent, result = pid: we do nothing.
+            # If we're in the parent, result = pid: trigger parent callbacks.
             # (If it gets called with a block, it only returns on the parent)
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if result.nil?
+            if result.nil?
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             result
           end
@@ -78,9 +204,23 @@ module Datadog
           # Hook provided by Ruby 3.1+ for observability libraries that want to know about fork, see
           # https://github.com/ruby/ruby/pull/5017 and https://bugs.ruby-lang.org/issues/17795
           def _fork
-            pid = super
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              pid = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed, so no child was
+              # created. Restore state set up by any earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if pid == 0
+            if pid == 0
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             pid
           end
@@ -89,9 +229,21 @@ module Datadog
           # keeps executing code in the child process, killing off the parent, thus effectively replacing it.
           # This is not covered by `_fork` and thus we have some extra code for it.
           def daemon(*args)
-            result = super
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              result = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # `daemon` or a before-fork callback failed, so the original
+              # process survives. Restore state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
-            AtForkMonkeyPatch.run_at_fork_blocks(:child)
+            # `daemon` kills the parent, so there is no surviving parent to run
+            # `:parent` callbacks in; only the child continues executing.
+            AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
 
             result
           end

data/lib/datadog/core/utils/base64_codec.rb

@@ -7,15 +7,15 @@ module Datadog
       # which is no longer a default gem since Ruby 3.4.
       module Base64Codec
         def self.encode64(bin)
-          [bin].pack('m')
+          [bin].pack("m")
         end
 
         def self.strict_encode64(bin)
-          [bin].pack('m0')
+          [bin].pack("m0")
         end
 
         def self.strict_decode64(str)
-          str.unpack1('m0') #: String # 'm0' format always returns a String
+          str.unpack1("m0") #: String # 'm0' format always returns a String
         end
       end
     end

data/lib/datadog/core/utils/duration.rb

@@ -6,7 +6,7 @@ module Datadog
       # Helper methods for parsing string values into Numeric
       module Duration
         def self.call(value, base: :s)
-          cast = if value.include?('.')
+          cast = if value.include?(".")
             method(:Float)
           else
             method(:Integer)

data/lib/datadog/core/utils/forking.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../ruby_version'
+require_relative "../../ruby_version"
 
 module Datadog
   module Core
@@ -47,7 +47,7 @@ module Datadog
           # object will cause forking to not be detected in the fork when it should have.
           #
           # This wrapper prevents this by initializing the fork PID when the object is created.
-          if RubyVersion.is?('>= 3')
+          if RubyVersion.is?(">= 3")
             def initialize(*args, **kwargs, &block)
               super
               update_fork_pid!

data/lib/datadog/core/utils/lru_cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+require "forwardable"
 
 module Datadog
   module Core
@@ -16,8 +16,8 @@ module Datadog
         def_delegators :@store, :clear, :empty?
 
         def initialize(max_size)
-          raise ArgumentError, 'max_size must be an Integer' unless max_size.is_a?(Integer)
-          raise ArgumentError, 'max_size must be greater than 0' if max_size <= 0
+          raise ArgumentError, "max_size must be an Integer" unless max_size.is_a?(Integer)
+          raise ArgumentError, "max_size must be greater than 0" if max_size <= 0
 
           @max_size = max_size
           @store = {}