twingly-metrics 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f844f321fabb39da0b4fb3bc79df69a6d16586d16675b3625df796bc58c6ca
-  data.tar.gz: 9373cdfe43cc5637803e1d87999944372e8d1260b24ae8964b16fd3d49642f8e
+  metadata.gz: 3d5cfa50a735b939760dc8242470280217152c47bca4bc4e0de092d405529399
+  data.tar.gz: e754a813aeeb419c14c33c342f04781c6cd544af203b3a2c2f74e9d999a2260e
 SHA512:
-  metadata.gz: '0845dcb417c724ab4e0c921c4a5d15a0bb17edf12c1e34543a5f42462309b076d178deb85f71962bfd8a88c8a838379e3f74a23c8cdfbedc05278d19e6eba5ee'
-  data.tar.gz: 362a8ff8636fecf2306ca58a9e69cfd97112a388eef9d8bab1549bf1c9c2b261416eeb5915fbc62d80c40347c3ab56d3db0d48f4b6f50c5d8603458fb917a56d
+  metadata.gz: 9d41769505fd9f03261afc987f33cb469b61ca5273aeedb624718062848c05866dde2abc28afbe9ec409ab5406aa21c087da0e663515cfdb921bd1cefb962699
+  data.tar.gz: 0bf2a9be9289336f4cd04be6d1af51f23125c20c986768be19d74e613790427d3b8cd4704f813539f38df8ecc5593da24b145091d43ef27099399dccdd5ff1e5

data/README.md

@@ -4,7 +4,7 @@
 
 A gem for collecting and reporting metrics from our Ruby applications.
 
-This gem currently relies on the [`metriks` gem][metriks] for collecting metrics. The reason for this is that we're already using that gem in our projects. What the `twingly-metrics` gem currently adds in functionality, is the ability to report metrics to [Grafana cloud][grafana-cloud], using their [Graphite HTTP API][grafana-cloud-graphite-api], along with some convenience methods for working with metrics.
+This gem provides its own implementation of common metric types and the ability to report them to [Grafana Cloud][grafana-cloud] using their [Graphite HTTP API][grafana-cloud-graphite-api].
 
 The code here was inspired by the reporter in the [`metriks-librato_metrics` gem][metriks-librato_metrics].
 
@@ -86,7 +86,6 @@ Twingly::Metrics.mark("my_meter", 1)
 Twingly::Metrics.time("my_timer") { ... }
 ```
 
-[metriks]: https://github.com/eric/metriks
 [grafana-cloud]: https://grafana.com/products/cloud/
 [grafana-cloud-graphite-api]: https://grafana.com/docs/grafana-cloud/send-data/metrics/metrics-graphite/http-api/#adding-new-data-posting-to-metrics
 [metriks-librato_metrics]: https://github.com/eric/metriks-librato_metrics

data/lib/twingly/metrics/counter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+module Twingly
+  module Metrics
+    # Public: Counters are one of the simplest metrics whose only operations
+    # are increment and decrement.
+    class Counter
+      # Public: Initialize a new Counter.
+      def initialize
+        @count = Atomic.new(0)
+      end
+
+      # Public: Reset the counter back to 0
+      #
+      # Returns nothing.
+      def clear
+        @count.value = 0
+      end
+
+      # Public: Increment the counter.
+      #
+      # incr - The value to add to the counter.
+      #
+      # Returns nothing.
+      def increment(incr = 1)
+        @count.update { |v| v + incr }
+      end
+
+      # Public: Decrement the counter.
+      #
+      # decr - The value to subtract from the counter.
+      #
+      # Returns nothing.
+      def decrement(decr = 1)
+        @count.update { |v| v - decr }
+      end
+
+      # Public: The current count.
+      #
+      # Returns the count.
+      def count
+        @count.value
+      end
+    end
+  end
+end

data/lib/twingly/metrics/ewma.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+module Twingly
+  module Metrics
+    class EWMA
+      INTERVAL = 5.0
+      SECONDS_PER_MINUTE = 60.0
+
+      ONE_MINUTE      = 1
+      FIVE_MINUTES    = 5
+      FIFTEEN_MINUTES = 15
+
+      M1_ALPHA  = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / ONE_MINUTE)
+      M5_ALPHA  = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / FIVE_MINUTES)
+      M15_ALPHA = 1 - Math.exp(-INTERVAL / SECONDS_PER_MINUTE / FIFTEEN_MINUTES)
+
+      def self.new_m1
+        new(M1_ALPHA, INTERVAL)
+      end
+
+      def self.new_m5
+        new(M5_ALPHA, INTERVAL)
+      end
+
+      def self.new_m15
+        new(M15_ALPHA, INTERVAL)
+      end
+
+      def initialize(alpha, interval)
+        @alpha    = alpha
+        @interval = interval
+
+        @initialized = false
+        @rate        = Atomic.new(0.0)
+        @uncounted   = Atomic.new(0)
+      end
+
+      def clear
+        @initialized = false
+        @rate.value = 0.0
+        @uncounted.value = 0
+      end
+
+      def update(value)
+        @uncounted.update { |v| v + value }
+      end
+
+      def tick
+        count = @uncounted.swap(0)
+        instant_rate = count / @interval.to_f
+
+        if @initialized
+          @rate.update { |v| v + (@alpha * (instant_rate - v)) }
+        else
+          @rate.value = instant_rate
+          @initialized = true
+        end
+      end
+
+      def rate
+        @rate.value
+      end
+    end
+  end
+end

data/lib/twingly/metrics/exponentially_decaying_sample.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "atomic"
+require "red_black_tree"
+require_relative "snapshot"
+
+module Twingly
+  module Metrics
+    class ExponentiallyDecayingSample
+      RESCALE_THRESHOLD = 60 * 60 # 1 hour
+
+      def initialize(reservoir_size, alpha, values = nil)
+        @values = values || ConcurrentRedBlackTree.new
+        @count = Atomic.new(0)
+        @next_scale_time = Atomic.new(0)
+        @alpha = alpha
+        @reservoir_size = reservoir_size
+        @mutex = Mutex.new
+        clear
+      end
+
+      def clear
+        @mutex.synchronize do
+          @values.clear
+          @count.value = 0
+          @next_scale_time.value = Time.now + RESCALE_THRESHOLD
+          @start_time = Time.now
+        end
+      end
+
+      def size
+        count = @count.value
+        [count, @reservoir_size].min
+      end
+
+      def snapshot
+        @mutex.synchronize do
+          Snapshot.new(@values.values)
+        end
+      end
+
+      def update(value, timestamp = Time.now) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        @mutex.synchronize do
+          priority = weight(timestamp - @start_time) / rand
+          priority = Float::MAX if priority.infinite?
+          new_count = @count.update { |v| v + 1 }
+
+          if priority.nan?
+            warn "ExponentiallyDecayingSample found priority of NaN. " \
+                 "timestamp: #{timestamp.to_f} start_time: #{@start_time.to_f}"
+            return
+          end
+
+          if new_count <= @reservoir_size
+            @values[priority] = value
+          else
+            first_priority = @values.first[0]
+            if first_priority < priority
+              unless @values[priority] # rubocop:disable Style/SoleNestedConditional
+                @values[priority] = value
+
+                first_priority = @values.first[0] until @values.delete(first_priority) # rubocop:disable Metrics/BlockNesting
+              end
+            end
+          end
+        end
+
+        now = Time.new
+        next_time = @next_scale_time.value
+        return unless now >= next_time
+
+        rescale(now, next_time)
+      end
+
+      def weight(time)
+        Math.exp(@alpha * time)
+      end
+
+      def rescale(now, next_time) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        return unless @next_scale_time.compare_and_swap(next_time, now + RESCALE_THRESHOLD)
+
+        @mutex.synchronize do
+          old_start_time = @start_time
+          @start_time = Time.now
+          @values.keys.each do |key|
+            value = @values.delete(key)
+            new_key = key * Math.exp(-@alpha * (@start_time - old_start_time))
+
+            if key.nan?
+              warn "ExponentiallyDecayingSample found a key of NaN. " \
+                   "old_start_time: #{old_start_time.to_f} start_time: #{@start_time.to_f}"
+              next
+            end
+
+            if new_key.nan?
+              warn "ExponentiallyDecayingSample found a new_key of NaN. " \
+                   "key: #{key} old_start_time: #{old_start_time.to_f} start_time: #{@start_time.to_f}"
+              next
+            end
+
+            @values[new_key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twingly/metrics/gauge.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+module Twingly
+  module Metrics
+    class Gauge
+      # Public: Initialize a new Gauge.
+      def initialize(callable = nil, &block)
+        @gauge = Atomic.new(nil)
+        @callback = callable || block
+      end
+
+      # Public: Set a new value.
+      #
+      # val - The new value.
+      #
+      # Returns nothing.
+      def set(val)
+        @gauge.value = val
+      end
+
+      # Public: The current value.
+      #
+      # Returns the gauge value.
+      def value
+        @callback ? @callback.call : @gauge.value
+      end
+    end
+  end
+end

data/lib/twingly/metrics/grafana_cloud_reporter.rb

@@ -2,8 +2,8 @@
 
 require "net/https"
 require "json"
-require "metriks"
 require "socket"
+require_relative "registry"
 
 module Twingly
   module Metrics
@@ -28,10 +28,10 @@ module Twingly
       end
 
       METRIC_TYPE_TO_BUILD_METHOD = {
-        Metriks::Meter   => :build_meter_metric,
-        Metriks::Counter => :build_counter_metric,
-        Metriks::Gauge   => :build_gauge_metric,
-        Metriks::Timer   => :build_timer_metric,
+        Twingly::Metrics::Meter   => :build_meter_metric,
+        Twingly::Metrics::Counter => :build_counter_metric,
+        Twingly::Metrics::Gauge   => :build_gauge_metric,
+        Twingly::Metrics::Timer   => :build_timer_metric,
       }.freeze
 
       attr_reader :endpoint
@@ -55,7 +55,7 @@ module Twingly
 
         log_missing_credentials unless credentials_provided?
 
-        @registry = options[:registry] || Metriks::Registry.default
+        @registry = options[:registry] || Twingly::Metrics::Registry.default
         @interval = options[:interval] || 60
         @on_error = options[:on_error] || proc { |ex| @logger&.error(ex) }
         @timeout  = options[:timeout]  || 10
@@ -158,7 +158,7 @@ module Twingly
 
         begin
           yield
-        rescue RequestFailedError => e
+        rescue RequestFailedError, Net::OpenTimeout, Net::ReadTimeout => e
           retries += 1
 
           raise if retries > max_retries
@@ -223,7 +223,7 @@ module Twingly
 
           time_metrics << build_grafana_metric("#{name}.median", snapshot.median, time)
 
-          build_timer_metric_percentiles(name, snapshot, time) { |metric| time_metrics << metric }
+          build_timer_metric_percentiles(name, snapshot, time) { |percentile_metric| time_metrics << percentile_metric }
         end
       end
 

data/lib/twingly/metrics/histogram.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "atomic"
+require_relative "snapshot"
+require_relative "uniform_sample"
+require_relative "exponentially_decaying_sample"
+
+module Twingly
+  module Metrics
+    class Histogram
+      DEFAULT_SAMPLE_SIZE = 1028
+      DEFAULT_ALPHA = 0.015
+
+      def self.new_uniform
+        new(Twingly::Metrics::UniformSample.new(DEFAULT_SAMPLE_SIZE))
+      end
+
+      def self.new_exponentially_decaying
+        new(Twingly::Metrics::ExponentiallyDecayingSample.new(DEFAULT_SAMPLE_SIZE, DEFAULT_ALPHA))
+      end
+
+      def initialize(sample)
+        @sample   = sample
+        @count    = Atomic.new(0)
+        @min      = Atomic.new(nil)
+        @max      = Atomic.new(nil)
+        @sum      = Atomic.new(0)
+        @variance = Atomic.new([-1, 0])
+      end
+
+      def clear
+        @sample.clear
+        @count.value = 0
+        @min.value = nil
+        @max.value = nil
+        @sum.value = 0
+        @variance.value = [-1, 0]
+      end
+
+      def update(value)
+        @count.update { |v| v + 1 }
+        @sample.update(value)
+        self.max = value
+        self.min = value
+        @sum.update { |v| v + value }
+        update_variance(value)
+      end
+
+      def snapshot
+        @sample.snapshot
+      end
+
+      def count
+        @count.value
+      end
+
+      def sum
+        @sum.value
+      end
+
+      def max
+        count.positive? ? @max.value : 0.0
+      end
+
+      def min
+        count.positive? ? @min.value : 0.0
+      end
+
+      def mean
+        count.positive? ? @sum.value / count : 0.0
+      end
+
+      def stddev
+        count.positive? ? variance**0.5 : 0.0
+      end
+
+      def variance
+        count <= 1 ? 0.0 : @variance.value[1] / (count - 1)
+      end
+
+      def max=(potential_max)
+        done = false
+
+        until done
+          current_max = @max.value
+          done = (!current_max.nil? && current_max >= potential_max) || @max.compare_and_swap(current_max,
+                                                                                              potential_max)
+        end
+      end
+
+      def min=(potential_min)
+        done = false
+
+        until done
+          current_min = @min.value
+          done = (!current_min.nil? && current_min <= potential_min) || @min.compare_and_swap(current_min,
+                                                                                              potential_min)
+        end
+      end
+
+      def update_variance(value) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        @variance.update do |old_values|
+          new_values = Array.new(2)
+          if old_values[0] == -1
+            new_values[0] = value
+            new_values[1] = 0
+          else
+            old_m = old_values[0]
+            old_s = old_values[1]
+
+            new_m = old_m + ((value - old_m) / count)
+            new_s = old_s + ((value - old_m) * (value - new_m))
+
+            new_values[0] = new_m
+            new_values[1] = new_s
+          end
+
+          new_values
+        end
+      end
+    end
+  end
+end

data/lib/twingly/metrics/meter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+require_relative "ewma"
+
+module Twingly
+  module Metrics
+    class Meter
+      TICK_INTERVAL = 5.0
+
+      def initialize(averager_klass = Twingly::Metrics::EWMA)
+        @count = Atomic.new(0)
+        @start_time = Time.now.to_f
+        @last_tick = Atomic.new(@start_time)
+
+        @m1_rate  = averager_klass.new_m1
+        @m5_rate  = averager_klass.new_m5
+        @m15_rate = averager_klass.new_m15
+      end
+
+      def clear
+        @count.value = 0
+        @start_time = Time.now.to_f
+        @last_tick.value = @start_time
+        @m1_rate.clear
+        @m5_rate.clear
+        @m15_rate.clear
+      end
+
+      def tick
+        @m1_rate.tick
+        @m5_rate.tick
+        @m15_rate.tick
+      end
+
+      def tick_if_nessesary
+        old_tick = @last_tick.value
+        new_tick = Time.new.to_f
+        age = new_tick - old_tick
+        return unless age > TICK_INTERVAL && @last_tick.compare_and_swap(old_tick, new_tick)
+
+        required_ticks = age / TICK_INTERVAL
+        required_ticks.to_i.times do
+          tick
+        end
+      end
+
+      def mark(val = 1)
+        tick_if_nessesary
+        @count.update { |v| v + val }
+        @m1_rate.update(val)
+        @m5_rate.update(val)
+        @m15_rate.update(val)
+      end
+
+      def count
+        @count.value
+      end
+
+      def one_minute_rate
+        tick_if_nessesary
+        @m1_rate.rate
+      end
+
+      def five_minute_rate
+        tick_if_nessesary
+        @m5_rate.rate
+      end
+
+      def fifteen_minute_rate
+        tick_if_nessesary
+        @m15_rate.rate
+      end
+
+      def mean_rate
+        return 0.0 if count.zero?
+
+        elapsed = Time.now.to_f - @start_time
+        count / elapsed
+      end
+
+      def stop; end
+    end
+  end
+end

data/lib/twingly/metrics/registry.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require_relative "counter"
+require_relative "timer"
+require_relative "utilization_timer"
+require_relative "meter"
+require_relative "gauge"
+
+module Twingly
+  module Metrics
+    # Public: A collection of metrics
+    class Registry
+      # Public: The default registry for the process.
+      #
+      # Returns the default Registry for the process.
+      def self.default
+        @default ||= new
+      end
+
+      # Public: Initializes a new Registry.
+      def initialize
+        @mutex = Mutex.new
+        @metrics = {}
+      end
+
+      # Public: Clear all of the metrics in the Registry. This ensures all
+      # metrics that have been added are stopped.
+      #
+      # Returns nothing.
+      def clear
+        @mutex.synchronize do
+          @metrics.each_value do |metric|
+            metric.stop if metric.respond_to?(:stop)
+          end
+
+          @metrics = {}
+        end
+      end
+
+      # Public: Clear all of the metrics in the Registry. This has the same
+      # effect as calling #clear.
+      #
+      # Returns nothing.
+      def stop
+        clear
+      end
+
+      # Public: Iterate over all of the counters.
+      #
+      # Examples
+      #
+      #   registry.each do |name, metric|
+      #     puts name
+      #   end
+      #
+      # Returns nothing.
+      def each(&block)
+        metrics = @mutex.synchronize do
+          @metrics.dup
+        end
+
+        metrics.each(&block)
+      end
+
+      # Public: Fetch or create a new counter metric. Counters are one of the
+      # simplest metrics whose only operations are increment and decrement.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.counter('method.calls')
+      #
+      # Returns the Metrics::Counter identified by the name.
+      def counter(name)
+        add_or_get(name, Metrics::Counter)
+      end
+
+      # Public: Fetch or create a new gauge metric.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.gauge('disk_space.used') { 1 }
+      #
+      # Returns the Metrics::Gauge identified by the name.
+      def gauge(name, callable = nil, &block)
+        add_or_get(name, Metrics::Gauge) do
+          Metrics::Gauge.new(callable, &block)
+        end
+      end
+
+      # Public: Fetch or create a new meter metric. Meters are a counter that
+      # tracks throughput along with the count.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.meter('resque.calls')
+      #
+      # Returns the Metrics::Meter identified by the name.
+      def meter(name)
+        add_or_get(name, Metrics::Meter)
+      end
+
+      # Public: Fetch or create a new timer metric. Timers provide the means to
+      # time the execution of a method including statistics on the number of
+      # invocations, average length of time, throughput.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.timer('resque.worker')
+      #
+      # Returns the Metrics::Timer identified by the name.
+      def timer(name)
+        add_or_get(name, Metrics::Timer)
+      end
+
+      # Public: Fetch or create a new utilization timer metric.
+      #
+      # Utilization timers are a specialized version of a timer that calculate
+      # the percentage of wall-clock time (between 0 and 1) that was spent in
+      # the method. This metric is most valuable in a single-threaded
+      # environment where a processes is waiting on an external resource like a
+      # message queue or HTTP server.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.utilization_timer('rack.utilization')
+      #
+      # Returns the Metrics::UtilizationTimer identified by the name.
+      def utilization_timer(name)
+        add_or_get(name, Metrics::UtilizationTimer)
+      end
+
+      # Public: Fetch or create a new histogram metric. Histograms record values
+      # and expose statistics about the distribution of the data like median and
+      # 95th percentile.
+      #
+      # name - The String name of the metric to define or fetch
+      #
+      # Examples
+      #
+      #   registry.histogram('backlog.wait')
+      #
+      # Returns the Metrics::Histogram identified by the name.
+      def histogram(name)
+        add_or_get(name, Metrics::Histogram) do
+          Metrics::Histogram.new_exponentially_decaying
+        end
+      end
+
+      # Public: Fetch an existing metric.
+      #
+      # name - The String name of the metric to fetch
+      #
+      # Examples
+      #
+      #   registry.get('rack.utilization')
+      #
+      # Returns the metric or nil.
+      def get(name)
+        @mutex.synchronize do
+          @metrics[name]
+        end
+      end
+
+      # Public: Add a new metric.
+      #
+      # name - The String name of the metric to add
+      # metric - The metric instance to add
+      #
+      # Examples
+      #
+      #   registry.add('method.calls', Metrics::Counter.new)
+      #
+      # Returns nothing.
+      # Raises RuntimeError if the metric name is already defined
+      def add(name, metric)
+        @mutex.synchronize do
+          raise "Metric '#{name}' already defined" if @metrics[name]
+
+          @metrics[name] = metric
+        end
+      end
+
+      protected
+
+      def add_or_get(name, klass, &create_metric)
+        @mutex.synchronize do
+          if (metric = @metrics[name])
+            raise "Metric already defined as '#{metric.class}'" unless metric.is_a?(klass)
+
+            return metric
+
+          else
+            @metrics[name] = create_metric ? create_metric.call : klass.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twingly/metrics/simple_moving_average.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+module Twingly
+  module Metrics
+    class SimpleMovingAverage
+      INTERVAL = 5.0
+      SECONDS_PER_MINUTE = 60.0
+
+      ONE_MINUTE      = 1
+      FIVE_MINUTES    = 5
+      FIFTEEN_MINUTES = 15
+
+      def self.new_m1
+        new(ONE_MINUTE * SECONDS_PER_MINUTE, INTERVAL)
+      end
+
+      def self.new_m5
+        new(FIVE_MINUTES * SECONDS_PER_MINUTE, INTERVAL)
+      end
+
+      def self.new_m15
+        new(FIFTEEN_MINUTES * SECONDS_PER_MINUTE, INTERVAL)
+      end
+
+      def initialize(duration, interval)
+        @interval = interval
+        @duration = duration
+
+        @values = Array.new((duration / interval).to_i) { Atomic.new(nil) }
+        @index  = Atomic.new(0)
+      end
+
+      def clear
+        @values.each do |value|
+          value.value = nil
+        end
+        @index.value = 0
+      end
+
+      def update(value)
+        @values[@index.value].update { |v| v ? v + value : value }
+      end
+
+      def tick
+        next_index = @index.update { |v| v < @values.length - 1 ? v + 1 : 0 }
+        @values[next_index].value = nil
+      end
+
+      def rate
+        num = 0.0
+        count = 0.0
+
+        @values.each do |value|
+          if (v = value.value)
+            num   += v
+            count += 1
+          end
+        end
+
+        return 0.0 if count.zero?
+
+        num / count / @interval.to_f
+      end
+    end
+  end
+end

data/lib/twingly/metrics/snapshot.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Twingly
+  module Metrics
+    class Snapshot
+      MEDIAN_Q = 0.5
+      P75_Q = 0.75
+      P95_Q = 0.95
+      P98_Q = 0.98
+      P99_Q = 0.99
+      P999_Q = 0.999
+
+      attr_reader :values
+
+      def initialize(values)
+        @values = values.sort
+      end
+
+      def value(quantile) # rubocop:disable Metrics/AbcSize
+        raise ArgumentError, "quantile must be between 0.0 and 1.0" if quantile < 0.0 || quantile > 1.0
+
+        return 0.0 if @values.empty?
+
+        pos = quantile * (@values.length + 1)
+
+        return @values.first if pos < 1
+        return @values.last if pos >= @values.length
+
+        lower = @values[pos.to_i - 1]
+        upper = @values[pos.to_i]
+        lower + ((pos - pos.floor) * (upper - lower))
+      end
+
+      def size
+        @values.length
+      end
+
+      def median
+        value(MEDIAN_Q)
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def get_75th_percentile
+        value(P75_Q)
+      end
+
+      def get_95th_percentile
+        value(P95_Q)
+      end
+
+      def get_98th_percentile
+        value(P98_Q)
+      end
+
+      def get_99th_percentile
+        value(P99_Q)
+      end
+
+      def get_999th_percentile
+        value(P999_Q)
+      end
+      # rubocop:enable Naming/AccessorMethodName
+    end
+  end
+end

data/lib/twingly/metrics/time_tracker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Twingly
+  module Metrics
+    class TimeTracker
+      def initialize(interval)
+        @interval = interval
+        @next_time = Time.now.to_f
+      end
+
+      def sleep
+        sleep_time = next_time - Time.now.to_f
+        return unless sleep_time.positive?
+
+        Kernel.sleep(sleep_time)
+      end
+
+      def now_floored
+        time = Time.now.to_i
+        time - (time % @interval)
+      end
+
+      def next_time
+        now = Time.now.to_f
+        @next_time = now if @next_time <= now
+        @next_time += @interval - (@next_time % @interval)
+      end
+    end
+  end
+end

data/lib/twingly/metrics/timer.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "atomic"
+
+require_relative "meter"
+require_relative "histogram"
+
+module Twingly
+  module Metrics
+    class Timer
+      class Context
+        def initialize(timer)
+          @timer    = timer
+          @interval = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def restart
+          @interval = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def stop
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @interval
+          @timer.update(duration)
+        end
+      end
+
+      def initialize(histogram = Twingly::Metrics::Histogram.new_exponentially_decaying)
+        @meter     = Twingly::Metrics::Meter.new
+        @histogram = histogram
+      end
+
+      def clear
+        @meter.clear
+        @histogram.clear
+      end
+
+      def update(duration)
+        return unless duration >= 0
+
+        @meter.mark
+        @histogram.update(duration)
+      end
+
+      def time(callable = nil, &block)
+        callable ||= block
+        context = Context.new(self)
+
+        return context if callable.nil?
+
+        begin
+          callable.call
+        ensure
+          context.stop
+        end
+      end
+
+      def snapshot
+        @histogram.snapshot
+      end
+
+      def count
+        @histogram.count
+      end
+
+      def sum
+        @histogram.sum
+      end
+
+      def one_minute_rate
+        @meter.one_minute_rate
+      end
+
+      def five_minute_rate
+        @meter.five_minute_rate
+      end
+
+      def fifteen_minute_rate
+        @meter.fifteen_minute_rate
+      end
+
+      def mean_rate
+        @meter.mean_rate
+      end
+
+      def min
+        @histogram.min
+      end
+
+      def max
+        @histogram.max
+      end
+
+      def mean
+        @histogram.mean
+      end
+
+      def stddev
+        @histogram.stddev
+      end
+
+      def stop
+        @meter.stop
+      end
+    end
+  end
+end

data/lib/twingly/metrics/uniform_sample.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "atomic"
+require_relative "snapshot"
+
+module Twingly
+  module Metrics
+    class UniformSample
+      def initialize(reservoir_size)
+        @values = Array.new(reservoir_size, 0)
+        @count  = Atomic.new(0)
+      end
+
+      def clear
+        @values.length.times do |idx|
+          @values[idx] = 0
+        end
+        @count.value = 0
+      end
+
+      def size
+        count = @count.value
+        [count, @values.length].min
+      end
+
+      def snapshot
+        Snapshot.new(@values.slice(0, size))
+      end
+
+      def update(value)
+        new_count = @count.update { |v| v + 1 }
+
+        if new_count <= @values.length
+          @values[new_count - 1] = value
+        else
+          idx = rand(new_count)
+          @values[idx] = value if idx < @values.length
+        end
+      end
+    end
+  end
+end

data/lib/twingly/metrics/utilization_timer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "timer"
+
+module Twingly
+  module Metrics
+    class UtilizationTimer < Metrics::Timer
+      def initialize
+        super
+        @duration_meter = Metrics::Meter.new
+      end
+
+      def clear
+        super
+        @duration_meter.clear
+      end
+
+      def update(duration)
+        return unless duration >= 0
+
+        super
+        @duration_meter.mark(duration)
+      end
+
+      def one_minute_utilization
+        @duration_meter.one_minute_rate
+      end
+
+      def five_minute_utilization
+        @duration_meter.five_minute_rate
+      end
+
+      def fifteen_minute_utilization
+        @duration_meter.fifteen_minute_rate
+      end
+
+      def mean_utilization
+        @duration_meter.mean_rate
+      end
+
+      def stop
+        super
+        @duration_meter.stop
+      end
+    end
+  end
+end

data/lib/twingly/metrics/version.rb

@@ -2,6 +2,6 @@
 
 module Twingly
   module Metrics
-    VERSION = "0.5.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/twingly/metrics.rb

@@ -1,40 +1,57 @@
 # frozen_string_literal: true
 
-require "metriks"
-
 require_relative "metrics/version"
+require_relative "metrics/registry"
 require_relative "metrics/grafana_cloud_reporter"
+require_relative "metrics/counter"
+require_relative "metrics/timer"
+require_relative "metrics/utilization_timer"
+require_relative "metrics/meter"
+require_relative "metrics/gauge"
+require_relative "metrics/histogram"
 
 module Twingly
   module Metrics
+    def self.get(name)
+      Registry.default.get(name)
+    end
+
     def self.counter(name)
-      Metriks.counter(name)
+      Registry.default.counter(name)
     end
 
     def self.gauge(name, callable = nil, &block)
-      Metriks.gauge(name, callable, &block)
+      Registry.default.gauge(name, callable, &block)
     end
 
     def self.timer(name)
-      Metriks.timer(name)
+      Registry.default.timer(name)
+    end
+
+    def self.utilization_timer(name)
+      Registry.default.utilization_timer(name)
     end
 
     def self.meter(name)
-      Metriks.meter(name)
+      Registry.default.meter(name)
     end
 
     def self.mark(name, val = 1)
       meter(name).mark(val)
     end
 
+    def self.set(name, val)
+      gauge(name).set(val)
+    end
+
     def self.time(name, duration = nil, &block)
       return timer(name).update(duration) if duration
 
       timer(name).time(&block)
     end
 
-    def self.set(name, val)
-      gauge(name).set(val)
+    def self.histogram(name)
+      Registry.default.histogram(name)
     end
   end
 end

metadata

@@ -1,28 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: twingly-metrics
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Twingly AB
 bindir: bin
 cert_chain: []
-date: 2025-09-15 00:00:00.000000000 Z
+date: 2026-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: metriks
+  name: atomic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: avl_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 description: Collect and report metrics in Ruby applications, and report them to Graphite.
 email:
 - support@twingly.com
@@ -32,7 +46,20 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/twingly/metrics.rb
+- lib/twingly/metrics/counter.rb
+- lib/twingly/metrics/ewma.rb
+- lib/twingly/metrics/exponentially_decaying_sample.rb
+- lib/twingly/metrics/gauge.rb
 - lib/twingly/metrics/grafana_cloud_reporter.rb
+- lib/twingly/metrics/histogram.rb
+- lib/twingly/metrics/meter.rb
+- lib/twingly/metrics/registry.rb
+- lib/twingly/metrics/simple_moving_average.rb
+- lib/twingly/metrics/snapshot.rb
+- lib/twingly/metrics/time_tracker.rb
+- lib/twingly/metrics/timer.rb
+- lib/twingly/metrics/uniform_sample.rb
+- lib/twingly/metrics/utilization_timer.rb
 - lib/twingly/metrics/version.rb
 homepage: https://github.com/twingly/twingly-metrics
 licenses: []
@@ -52,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby library for collecting and reporting metrics.
 test_files: []