network_resiliency 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bf447ec73846d8911df202dc4a2ba576879a2768cd2a2e817ae9119a0e40506
-  data.tar.gz: d38481d92461272cbcefd34ea81f2c82d38381e135a06daed527210cdce6a178
+  metadata.gz: 9cd120266db1dfb8d2e5b37155534f3d5dc37a560d329352fa1a061ffd19ec97
+  data.tar.gz: c09fb2b6dc81e74a838e7da9ae9bc7e4d177c9ba7104a3b8e6ecb6b8668ebf97
 SHA512:
-  metadata.gz: 73b6e3fa940f4f8b91e26cc039b2bdfb37f7879a2a4c60ac1cc29e0572e79fd427c4984dfd8a139695e1225a370e295330833d81e250c6b3f922f467fb5f0b00
-  data.tar.gz: 00a8fe95736393d1e9133ca4d2d0c9873d859a93c53ef487503ad00762eadcaba18bad6c99138910a9bbf4916cc7eae5a464d8324657321b68eaaca076a5a10f
+  metadata.gz: 9caeeab2d22c4feea69b03438f8c66588179fe130ef1620935c475654a4661bbba36d82c79b4650fb3bcdead86cf0b5f3e3746513c40d16c8208b6f09ca32e5a
+  data.tar.gz: 05ad9ab8d5ec490cf6064cc83c54e9132b2a10f4bf6ab8ca0ab83f94d84db706622c951a49ad0de8e0ac7551ce32963fb86ca7aad5d6f47bb0c33162d3ba0e6d

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+###  v0.6.0  (2023-11-21)
+- http resiliency
+- redis resilience
+- spec cleanup
+
 ###  v0.5.1  (2023-11-17)
 - support nil timeouts
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    network_resiliency (0.5.1)
+    network_resiliency (0.6.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/network_resiliency/adapter/http.rb

@@ -15,19 +15,41 @@ module NetworkResiliency
         (instance&.singleton_class || Net::HTTP).ancestors.include?(Instrumentation)
       end
 
-      module Instrumentation
-        def connect
-          return super unless NetworkResiliency.enabled?(:http)
-          original_timeout = self.open_timeout
+      ID_REGEX = %r{/[0-9]+(?=/|$)}.freeze
+      UUID_REGEX = %r`/\h{8}-\h{4}-(\h{4})-\h{4}-\h{12}(?=/|$)`.freeze
+      refine Net::HTTP do
+        def normalize_path(path)
+          path.gsub(
+            Regexp.union(
+              NetworkResiliency::Adapter::HTTP::ID_REGEX,
+              NetworkResiliency::Adapter::HTTP::UUID_REGEX,
+            ),
+            '/x',
+          )
+        end
+
+        def with_resilience(action, destination, idempotent, &block)
+          if action == :connect
+            original_timeout = self.open_timeout
+            set_timeout = ->(timeout) { self.open_timeout = timeout }
+          else
+            original_timeout = self.read_timeout
+            set_timeout = ->(timeout) { self.read_timeout = timeout }
+          end
 
           timeouts = NetworkResiliency.timeouts_for(
             adapter: "http",
-            action: "connect",
-            destination: address,
+            action: action.to_s,
+            destination: destination,
             max: original_timeout,
             units: :seconds,
           )
 
+          unless idempotent
+            # only try once, with most lenient timeout
+            timeouts = timeouts.last(1)
+          end
+
           attempts = 0
           ts = -NetworkResiliency.timestamp
 
@@ -35,10 +57,13 @@ module NetworkResiliency
             attempts += 1
             error = nil
 
-            self.open_timeout = timeouts.shift
+            set_timeout.call(timeouts.shift)
+
+            yield
+          rescue ::Timeout::Error,
+             defined?(OpenSSL::SSL) ? OpenSSL::OpenSSLError : IOError,
+             SystemCallError => e
 
-            super
-          rescue Net::OpenTimeout => e
             # capture error
             error = e.class
 
@@ -47,20 +72,49 @@ module NetworkResiliency
             raise
           ensure
             ts += NetworkResiliency.timestamp
-            self.open_timeout = original_timeout
+            set_timeout.call(original_timeout)
 
             NetworkResiliency.record(
               adapter: "http",
-              action: "connect",
-              destination: address,
-              error: error,
+              action: action.to_s,
+              destination: destination,
               duration: ts,
-              timeout: self.open_timeout.to_f * 1_000,
+              error: error,
+              timeout: original_timeout.to_f * 1_000,
               attempts: attempts,
             )
           end
         end
       end
+
+      module Instrumentation
+        using NetworkResiliency::Adapter::HTTP
+
+        def connect
+          return super unless NetworkResiliency.enabled?(:http)
+
+          with_resilience(:connect, address, true) { super }
+        end
+
+        def transport_request(req, &block)
+          return super unless NetworkResiliency.enabled?(:http)
+
+          destination = [
+            req.method.downcase,
+            address,
+            normalize_path(req.path),
+          ].join(":")
+
+          idepotent = Net::HTTP::IDEMPOTENT_METHODS_.include?(req.method)
+
+          retries = self.max_retries
+          self.max_retries = 0 # disable
+
+          with_resilience(:request, destination, idepotent) { super }
+        ensure
+          self.max_retries = retries
+        end
+      end
     end
   end
 end

data/lib/network_resiliency/adapter/redis.rb

@@ -35,20 +35,44 @@ module NetworkResiliency
         end
       end
 
-      module Instrumentation
-        def establish_connection
-          return super unless NetworkResiliency.enabled?(:redis)
-
-          original_timeout = @options[:connect_timeout]
+      IDEMPOTENT_COMMANDS = [
+        "exists",
+        "expire",
+        "get",
+        "getex",
+        "getrange",
+        "mget",
+        "mset",
+        "ping",
+        "scard",
+        "sdiff",
+        "sdiffstore",
+        "set",
+        "sismember",
+        "smembers",
+        "smismember",
+      ].freeze
+
+      refine ::Redis::Client do
+        private
+
+        def with_resilience(action, destination, idempotent, &block)
+          timeout_key = action == :connect ? :connect_timeout : :read_timeout
+          original_timeout = @options[timeout_key]
 
           timeouts = NetworkResiliency.timeouts_for(
             adapter: "redis",
-            action: "connect",
-            destination: host,
-            max: original_timeout,
+            action: action.to_s,
+            destination: destination,
+            max: @options[timeout_key],
             units: :seconds,
           )
 
+          unless idempotent
+            # only try once, with most lenient timeout
+            timeouts = timeouts.last(1)
+          end
+
           attempts = 0
           ts = -NetworkResiliency.timestamp
 
@@ -56,10 +80,10 @@ module NetworkResiliency
             attempts += 1
             error = nil
 
-            @options[:connect_timeout] = timeouts.shift
+            @options[timeout_key] = timeouts.shift
 
-            super
-          rescue ::Redis::CannotConnectError => e
+            yield
+          rescue ::Redis::BaseConnectionError => e
             # capture error
 
             # grab underlying exception within Redis wrapper
@@ -70,19 +94,53 @@ module NetworkResiliency
             raise
           ensure
             ts += NetworkResiliency.timestamp
-            @options[:connect_timeout] = original_timeout
+            @options[timeout_key] = original_timeout
 
             NetworkResiliency.record(
               adapter: "redis",
-              action: "connect",
-              destination: host,
+              action: action.to_s,
+              destination: destination,
               duration: ts,
               error: error,
-              timeout: @options[:connect_timeout].to_f * 1_000,
+              timeout: @options[timeout_key].to_f * 1_000,
               attempts: attempts,
             )
           end
         end
+
+        def idempotent?(command)
+          NetworkResiliency::Adapter::Redis::IDEMPOTENT_COMMANDS.include?(command)
+        end
+      end
+
+      module Instrumentation
+        using NetworkResiliency::Refinements
+        using NetworkResiliency::Adapter::Redis
+
+        def establish_connection
+          return super unless NetworkResiliency.enabled?(:redis)
+
+          with_resilience(:connect, host, true) { super }
+        end
+
+        def call(command)
+          return super unless NetworkResiliency.enabled?(:redis)
+          return super unless command.is_a?(Array)
+
+          command_key = command.first.to_s
+
+          # larger commands may have larger timeouts
+          command_size = command.size.order_of_magnitude
+          destination = [
+            host,
+            command_key,
+            (command_size if command_size > 1),
+          ].compact.join(":")
+
+          idempotent = idempotent?(command_key)
+
+          with_resilience(:request, destination, idempotent) { super }
+        end
       end
     end
   end

data/lib/network_resiliency/version.rb

@@ -1,3 +1,3 @@
 module NetworkResiliency
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/network_resiliency.rb

@@ -299,7 +299,7 @@ module NetworkResiliency
     end
   end
 
-  private
+  # private
 
   def thread_state
     Thread.current["network_resiliency"] ||= {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: network_resiliency
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-17 00:00:00.000000000 Z
+date: 2023-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug