network_resiliency 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07f28c3158ada0009efdc0d9b68162419d227d088b24b3827a43dc5923ca8081
-  data.tar.gz: 645bd61e91ac8b939713376de77cedcd1f79e254a558b0b09cd26ba0280abe68
+  metadata.gz: b26da5cafa1321e4b284d8b3ade1184d4423973f388b1e4288b3be3d79153c3b
+  data.tar.gz: 6a4588995b8fdab21e424235bb31d2d83bef8d6b43d2b4ab1f9f3e9df08e19cf
 SHA512:
-  metadata.gz: 47b0bbe65d83b4acad810673904a13d57c898a00193fb48432b690d31932d19e52d397363195917f9e3dd8b1631084bdfd193094e8f570fb914ab490db9fd544
-  data.tar.gz: dd8f225e3bcf5d597838e405fa8c80b7228fdc5aacdf326b38c9fdb0eae72eae60bf00e0be1eed970547014b5f820557635cfd6422741e91c0e6e2cc22935bc6
+  metadata.gz: d6b110ad5631918d1077f4ba77a63da113fa9b19f156f439f6b46a2f8817d770740e157d07d7752b443568b3d1f86f416ff707d3ff0598a71b0355dabf1aa0c8
+  data.tar.gz: ab91f3ac1febb0504b8b0a64f0f12014636fd86bfc1ea3f1c1904a38660b8be791cc07835fed7154775d150bbc131243f4e892e255ecd7a96f68dbd7d1cd637a

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+###  v0.2.0  (2023-10-01)
+- high level patch
+- redis adapter
+- mock redis
+- freeze time in specs
+
+###  v0.1.1  (2023-09-27)
+- prevent double patching
+- filter ip addresses
+- simplify
+- configure
+
 ###  v0.1.0  (2023-09-26)
 - rework faraday adapter
 - faraday

data/Gemfile.lock

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

data/lib/network_resiliency/adapter/faraday.rb

@@ -5,7 +5,9 @@ module NetworkResiliency
     class Faraday < ::Faraday::Adapter::NetHttp
       def build_connection(env)
         super.tap do |conn|
-          NetworkResiliency::Adapter::HTTP.patch(conn)
+          unless NetworkResiliency::Adapter::HTTP.patched?(conn)
+            NetworkResiliency::Adapter::HTTP.patch(conn)
+          end
         end
       end
     end

data/lib/network_resiliency/adapter/http.rb

@@ -6,6 +6,8 @@ module NetworkResiliency
       extend self
 
       def patch(instance = nil)
+        return if patched?(instance)
+
         (instance&.singleton_class || Net::HTTP).prepend(Instrumentation)
       end
 
@@ -27,14 +29,12 @@ module NetworkResiliency
           ensure
             ts += NetworkResiliency.timestamp
 
-            NetworkResiliency.statsd&.distribution(
-              "network_resiliency.connect",
-              ts,
-              tags: {
-                adapter: "http",
-                destination: address,
-                error: e&.class,
-              }.compact,
+            NetworkResiliency.record(
+              adapter: "http",
+              action: "connect",
+              destination: address,
+              error: e&.class,
+              duration: ts,
             )
           end
         end

data/lib/network_resiliency/adapter/redis.rb

@@ -3,61 +3,73 @@ require "redis"
 module NetworkResiliency
   module Adapter
     module Redis
-      def connect(redis_config)
-        puts "RedisClient.connect(#{client.connect_timeout})"
+      extend self
 
-        old_timeout = client.connect_timeout
+      def patch(instance = nil)
+        return if patched?(instance)
 
-        already_connected = client.connected?
+        if instance
+          unless instance.is_a?(::Redis)
+            raise ArgumentError, "expected Redis instance, found: #{instance}"
+          end
 
-        # client.connect_timeout = 0.1
-        ts = -NetworkResiliency.timestamp
-        super
-      ensure
-        client.connect_timeout = old_timeout
+          client = instance.instance_variable_get(:@client)
 
-        ts += NetworkResiliency.timestamp
+          unless client.is_a?(::Redis::Client)
+            raise ArgumentError, "unsupported Redis client: #{client}"
+          end
 
-        note = already_connected ? " (already_connected)" : ""
+          client.singleton_class.prepend(Instrumentation)
+        else
+          ::Redis::Client.prepend(Instrumentation)
+        end
+      end
+
+      def patched?(instance = nil)
+        if instance
+          client = instance.instance_variable_get(:@client)
 
-        puts "connect time: #{ts}#{note}"
+          client && client.singleton_class.ancestors.include?(Instrumentation)
+        else
+          ::Redis::Client.ancestors.include?(Instrumentation)
+        end
       end
 
-      def call(command, redis_config)
-        puts "RedisClient.call"
+      module Instrumentation
+        # def initialize(...)
+        #   super
 
-        key = "#{id}:call"
-        ts = -NetworkResiliency.timestamp
-        with_timeout(1) { super }
-      ensure
-        ts += NetworkResiliency.timestamp
-        puts "call time: #{ts}"
+        #   @network_resiliency_attempts = options[:reconnect_attempts]
+        #   options[:reconnect_attempts] = 0
+        # end
 
-        NetworkResiliency.record(self, id, ts)
-      end
+        def establish_connection
+          return super unless NetworkResiliency.enabled?(:redis)
 
-      def id
-        "redis:#{client.host}"
-      end
+          begin
+            ts = -NetworkResiliency.timestamp
 
-      def with_timeout(timeout)
-        old_timeouts = [
-          client.connect_timeout,
-          client.read_timeout,
-          client.write_timeout,
-        ]
+            super
+          rescue ::Redis::CannotConnectError => e
+            # capture error
+            raise
+          ensure
+            ts += NetworkResiliency.timestamp
 
-        client.connect_timeout = timeout
-        client.read_timeout = timeout
-        client.write_timeout = timeout
+            # grab underlying exception within Redis wrapper
+            error = e ? e.cause.class : nil
 
-        yield
-      ensure
-        client.connect_timeout, client.read_timeout, client.write_timeout = *old_timeouts
+            NetworkResiliency.record(
+              adapter: "redis",
+              action: "connect",
+              destination: host,
+              error: error,
+              duration: ts,
+            )
+          end
+        end
       end
     end
   end
 end
 
-# RedisClient.register(NetworkResiliency::Adapter::Redis)
-# Redis.new(middlewares: [NetworkResiliency::Adapter::Redis])

data/lib/network_resiliency/version.rb

@@ -1,3 +1,3 @@
 module NetworkResiliency
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/network_resiliency.rb

@@ -11,10 +11,29 @@ module NetworkResiliency
 
   attr_accessor :statsd
 
+  def configure
+    yield self
+  end
+
+  def patch(*adapters)
+    adapters.each do |adapter|
+      case adapter
+      when :http
+        Adapter::HTTP.patch
+      when :redis
+        Adapter::Redis.patch
+      else
+        raise NotImplementedError
+      end
+    end
+  end
+
   def enabled?(adapter)
     return true if @enabled.nil?
 
-    @enabled.is_a?(Proc) ? @enabled.call(adapter) : @enabled
+    @enabled.is_a?(Proc) ? !!@enabled.call(adapter) : @enabled
+  rescue
+    false
   end
 
   def enabled=(enabled)
@@ -48,6 +67,25 @@ module NetworkResiliency
     Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1_000
   end
 
+  # private
+
+  IP_ADDRESS_REGEX = Regexp.new(/\d{1,3}(\.\d{1,3}){3}/)
+
+  def record(adapter:, action:, destination:, duration:, error: nil)
+    # filter raw IP addresses
+    return if IP_ADDRESS_REGEX.match?(destination)
+
+    NetworkResiliency.statsd&.distribution(
+      "network_resiliency.#{action}",
+      duration,
+      tags: {
+        adapter: adapter,
+        destination: destination,
+        error: error,
+      }.compact,
+    )
+  end
+
   def reset
     @enabled = nil
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: network_resiliency
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-27 00:00:00.000000000 Z
+date: 2023-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug