network_resiliency 0.7.10 → 0.7.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9ddcd8230d4e9ac39deb2aaea8dd4deca88043515a4e0a5e9e992c8ef4d45a2
-  data.tar.gz: 3784f0deb54c42adcbe6507b3883ee76976a1580a561832d47c61809263c46f5
+  metadata.gz: 93c15344f1a3f02c3ef567baeb1650745b27286a92db1975368a2066e29df423
+  data.tar.gz: '092ee5a69a9f6b3e2e299946404c83353bb142e7d6d596d7fe4d556640500c5f'
 SHA512:
-  metadata.gz: '0693d64108424d5d78087728f65a2c7aea2d3e891e4c0f2297ab6ada7278f3837413fbe7f343852dc88bbc0f883601d2f5b9c617ee2bc152380edbacfbfa0c2c'
-  data.tar.gz: c358bf2728f3892c310e90823ef6fb64dadbca5ab2ad1840e960dcc5cb1c17fc279e8f4cadc8b140727a13a713861b91552d60c30f48749c3909d8c4f8c03377
+  metadata.gz: 9a84c796661456dd272fa052647ec99991956f5d69435a8dd046a93634de0bbfdc5100cd7cb9b8dfb54d3641d18c71cb5b0728c70448ed6de40fa2bd181eb02e
+  data.tar.gz: d9487add703cd5c2ef71abbed8d913619338e240faceaaeac8621c58dbfe2af6203029328f37875f75315d94f91498a6283e252f3c3703fefd12b546e46745c1

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+###  v0.7.12  (2024-02-23)
+- improve metric sampling
+- lower resiliency threshold
+- power buckets
+
+###  v0.7.11  (2024-02-20)
+- lower dynamic timeout
+- fix metric specs
+- extend cache ttl
+
 ###  v0.7.10  (2024-02-15)
 - ddog sampling
 - reconnect redis

data/Gemfile.lock

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

data/README.md

@@ -39,3 +39,8 @@ Yes please  :)
 https://github.com/lostisland/faraday-retry/blob/main/lib/faraday/retry/middleware.rb
 
 https://github.com/ankane/the-ultimate-guide-to-ruby-timeouts
+
+
+https://reprep.io/writings/20220326_timeouts_deadline_propagation.html
+
+https://grpc.io/blog/deadlines

data/lib/network_resiliency/power_stats.rb

@@ -0,0 +1,132 @@
+require "network_resiliency/refinements"
+
+using NetworkResiliency::Refinements
+
+module NetworkResiliency
+  class PowerStats
+    MIN_VALUE = 1
+    LOCK = Thread::Mutex.new
+    STATS = {}
+
+    attr_reader :n
+
+    class << self
+      def [](key)
+        LOCK.synchronize { STATS[key] ||= new }
+      end
+
+      def reset
+        LOCK.synchronize { STATS.clear }
+      end
+
+      private
+
+      def synchronize(fn_name)
+        fn = instance_method(fn_name)
+
+        define_method(fn_name) do |*args|
+          @lock.synchronize { fn.bind(self).call(*args) }
+        end
+      end
+    end
+
+    def initialize(values = [])
+      @lock = Thread::Mutex.new
+      reset
+
+      values.each {|x| add(x) }
+    end
+
+    def <<(value)
+      case value
+      when Array
+        value.each {|x| add(x) }
+      when self.class
+        merge!(value)
+      else
+        add(value)
+      end
+
+      self
+    end
+
+    synchronize def add(value)
+      raise ArgumentError, "Numeric expected, found #{value.class}" unless value.is_a?(Numeric)
+
+      value = [ value, MIN_VALUE ].max
+      i = Math.log10(value).ceil
+
+      @buckets[i] ||= 0
+      @buckets[i] += 1
+      @n += 1
+    end
+
+    synchronize def percentile(p)
+      raise ArgumentError, "Percentile must be between 0 and 100" unless p.between?(0, 100)
+
+      return 0 if @n == 0
+
+      threshold = ((100 - p) / 100.0 * @n).floor
+      index = @buckets.size - 1
+
+      while index >= 0
+        if @buckets[index]
+          break if @buckets[index] >= threshold
+
+          threshold -= @buckets[index]
+        end
+
+        index -= 1
+      end
+
+      10 ** index
+    end
+    alias_method :p, :percentile
+
+    def p99
+      percentile(99)
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+    alias_method :+, :merge
+
+    synchronize def merge!(other)
+      raise ArgumentError unless other.is_a?(self.class)
+
+      other_buckets = other.instance_variable_get(:@buckets)
+
+      if @n == 0
+        @n = other.n
+        @buckets = other_buckets.dup
+      elsif other.n > 0
+        @n += other.n
+
+        other_buckets.each_with_index do |count, i|
+          next unless count
+
+          @buckets[i] ||= 0
+          @buckets[i] += count
+        end
+      end
+
+      self
+    end
+
+    synchronize def scale!(percentage)
+      raise ArgumentError, "Numeric expected, found #{percentage.class}" unless percentage.is_a?(Numeric)
+      raise ArgumentError, "argument must be between 0 and 100" unless percentage.between?(0, 100)
+
+      factor = percentage / 100.0
+
+      @buckets.map! {|x| (x * factor).round if x }
+      @n = @buckets.compact.sum
+    end
+
+    synchronize def reset
+      @n = 0
+      @buckets = []
+    end
+  end
+end

data/lib/network_resiliency/stats.rb

@@ -80,6 +80,16 @@ module NetworkResiliency
       self
     end
 
+    synchronize def scale!(percentage)
+      raise ArgumentError, "Numeric expected, found #{percentage.class}" unless percentage.is_a?(Numeric)
+      raise ArgumentError, "argument must be between 0 and 100" unless percentage.between?(0, 100)
+
+      factor = percentage / 100.0
+
+      @sq_dist *= factor
+      @n = (@n * factor).round
+    end
+
     def ==(other)
       return false unless other.is_a?(self.class)
 
@@ -94,10 +104,10 @@ module NetworkResiliency
       @sq_dist = 0.0 # sum of squared distance from mean
     end
 
-    MIN_SAMPLE_SIZE = 1000
+    MIN_SAMPLE_SIZE = 300
     MAX_WINDOW_LENGTH = 1000
     STATS_TTL = 24 * 60 * 60 # 1 day
-    CACHE_TTL = 60 # seconds
+    CACHE_TTL = 120 # seconds
 
     LUA_SCRIPT = <<~LUA
       local results = {}
@@ -189,11 +199,9 @@ module NetworkResiliency
       end
 
       res = redis.eval(LUA_SCRIPT, keys, args)
-      data.keys.zip(res.each_slice(3)).map do |key, stats|
-        n, avg, sq_dist = *stats
-
-        [ key, Stats.from(n: n, avg: avg, sq_dist: sq_dist) ]
-      end.to_h
+      data.keys.zip(res.each_slice(3)).to_h.transform_values! do |n, avg, sq_dist|
+        Stats.from(n: n, avg: avg, sq_dist: sq_dist)
+      end
     end
 
     def self.fetch(redis, keys)

data/lib/network_resiliency/version.rb

@@ -1,3 +1,3 @@
 module NetworkResiliency
-  VERSION = "0.7.10"
+  VERSION = "0.7.12"
 end

data/lib/network_resiliency.rb

@@ -1,3 +1,4 @@
+require "network_resiliency/power_stats"
 require "network_resiliency/refinements"
 require "network_resiliency/stats"
 require "network_resiliency/stats_engine"
@@ -19,7 +20,7 @@ module NetworkResiliency
   ACTIONS = [ :connect, :request ].freeze
   ADAPTERS = [ :http, :faraday, :redis, :mysql, :postgres, :rails ].freeze
   MODE = [ :observe, :resilient ].freeze
-  RESILIENCY_SIZE_THRESHOLD = 1_000
+  RESILIENCY_SIZE_THRESHOLD = 300
   SAMPLE_RATE = {
     timeout: 0.1,
     stats: 0.1,
@@ -266,26 +267,28 @@ module NetworkResiliency
       # ensure Syncer is running
       Syncer.start
 
-      NetworkResiliency.statsd&.distribution(
-        "network_resiliency.#{action}.stats.n",
-        stats.n,
-        tags: tags,
-        sample_rate: SAMPLE_RATE[:stats],
-      )
+      if rand < SAMPLE_RATE[:stats]
+        NetworkResiliency.statsd&.distribution(
+          "network_resiliency.#{action}.stats.n",
+          stats.n,
+          tags: tags,
+          sample_rate: SAMPLE_RATE[:stats],
+        )
 
-      NetworkResiliency.statsd&.distribution(
-        "network_resiliency.#{action}.stats.avg",
-        stats.avg,
-        tags: tags,
-        sample_rate: SAMPLE_RATE[:stats],
-      )
+        NetworkResiliency.statsd&.distribution(
+          "network_resiliency.#{action}.stats.avg",
+          stats.avg,
+          tags: tags,
+          sample_rate: SAMPLE_RATE[:stats],
+        )
 
-      NetworkResiliency.statsd&.distribution(
-        "network_resiliency.#{action}.stats.stdev",
-        stats.stdev,
-        tags: tags,
-        sample_rate: SAMPLE_RATE[:stats],
-      )
+        NetworkResiliency.statsd&.distribution(
+          "network_resiliency.#{action}.stats.stdev",
+          stats.stdev,
+          tags: tags,
+          sample_rate: SAMPLE_RATE[:stats],
+        )
+      end
     end
 
     nil
@@ -316,7 +319,7 @@ module NetworkResiliency
       destination: destination,
     }
 
-    p99 = (stats.avg + stats.stdev * 3).order_of_magnitude(ceil: true)
+    p99 = (stats.avg + stats.stdev * 2).order_of_magnitude(ceil: true)
 
     timeouts = []
 
@@ -337,7 +340,7 @@ module NetworkResiliency
             "network_resiliency.timeout.raised",
             tags: tags,
             sample_rate: SAMPLE_RATE[:timeout],
-          )
+          ) if rand < SAMPLE_RATE[:timeout]
         end
       else
         # the specified timeout is less than our expected p99...awkward
@@ -347,7 +350,7 @@ module NetworkResiliency
           "network_resiliency.timeout.too_low",
           tags: tags,
           sample_rate: SAMPLE_RATE[:timeout],
-        )
+        ) if rand < SAMPLE_RATE[:timeout]
       end
     else
       timeouts << p99
@@ -361,7 +364,7 @@ module NetworkResiliency
         "network_resiliency.timeout.missing",
         tags: tags,
         sample_rate: SAMPLE_RATE[:timeout],
-      )
+      ) if rand < SAMPLE_RATE[:timeout]
     end
 
     NetworkResiliency.statsd&.distribution(
@@ -372,7 +375,7 @@ module NetworkResiliency
         destination: destination,
       },
       sample_rate: SAMPLE_RATE[:timeout],
-    )
+    ) if rand < SAMPLE_RATE[:timeout]
 
     case units
     when nil, :ms, :milliseconds

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: network_resiliency
 version: !ruby/object:Gem::Version
-  version: 0.7.10
+  version: 0.7.12
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-15 00:00:00.000000000 Z
+date: 2024-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -238,6 +238,7 @@ files:
 - lib/network_resiliency/adapter/postgres.rb
 - lib/network_resiliency/adapter/rails.rb
 - lib/network_resiliency/adapter/redis.rb
+- lib/network_resiliency/power_stats.rb
 - lib/network_resiliency/refinements.rb
 - lib/network_resiliency/stats.rb
 - lib/network_resiliency/stats_engine.rb