ezmetrics 1.2.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 408332cfc86d05b75d8b6004098d736ad60a624189f46022af822fdf6c24960d
-  data.tar.gz: 6d4ef89fa6a80e28cb443e16f1528b351a93bf7bf50e2a8fc756dc943a25f11f
+  metadata.gz: 16333a0b9644e92d3f3648530e2217d6cc76eb2c427a63cf315d254f2e081cb6
+  data.tar.gz: 5dc280c1ec8594856addced752296731f9dfdc9ad7bae84625541d959f50f2d7
 SHA512:
-  metadata.gz: 99a4ac48560305d2967cdcc8b248978ee3f0748ab1fb7da2830a3804d732d29664f25bfdc4bd2bfa50c449994913ecd455362f57af1f39f0f45e904e36876c12
-  data.tar.gz: c53617fbc324765b9b388b1280b6d363a3707b002a2718cd0467a16ff24708a8adbf81a812aca111a643924de4834a155efdef252911195570837fdb8f6a9dce
+  metadata.gz: 48c142669ed79439784f8ed4c12d658169a51b125c2dbfd9e1324271d388fc69df3fe6c960b73970898ab088ca000335a405877c44722f717c38b2169a7c0bc4
+  data.tar.gz: c2503cd1900b0723db05e72dae3ee3c7633e46dabde7083f218fae8e0c3354c78edf1ab549b7e308d356017b171dc24da540d93fa4fe1b067f948de8df02e521

data/README.md

@@ -10,6 +10,16 @@ Simple, lightweight and fast metrics aggregation for Rails.
 gem 'ezmetrics'
 ```
 
+## Available metrics
+
+|    Type    |          Aggregate functions      |
+|:----------:|:---------------------------------:|
+| `duration` |  `avg`, `max`, `percentile`       |
+|   `views`  |  `avg`, `max`, `percentile`       |
+|    `db`    |  `avg`, `max`, `percentile`       |
+|  `queries` |  `avg`, `max`, `percentile`       |
+| `requests` | `all`, `2xx`, `3xx`, `4xx`, `5xx` |
+
 ## Usage
 
 ### Getting started
@@ -258,6 +268,48 @@ EZmetrics.new.show(views: :avg, :db: [:avg, :max], requests: true)
 }
 ```
 
+---
+
+**5. Percentile**
+
+This feature is available since version `2.0.0`.
+
+By default percentile aggregation is turned off because it requires to store each value of all metrics.
+
+To enable this feature - you need to set `store_each_value: true` when saving the metrics:
+
+```ruby
+EZmetrics.new.log(
+  duration:         100.5,
+  views:            40.7,
+  db:               59.8,
+  queries:          4,
+  status:           200,
+  store_each_value: true
+)
+```
+
+The aggregation syntax has the following format `metrics_type: :percentile_{number}` where `number` is any integer in the 1..99 range.
+
+
+```ruby
+EZmetrics.new.show(db: [:avg, :percentile_90, :percentile_95], duration: :percentile_99)
+```
+
+```ruby
+{
+  db: {
+    avg: 155,
+    percentile_90: 205,
+    percentile_95: 215
+  },
+  duration: {
+    percentile_99: 236
+  }
+}
+```
+
+
 ### Partitioning
 
 If you want to visualize your metrics by using a **line chart**, you will need to use partitioning.
@@ -317,6 +369,8 @@ Available time units for partitioning: `second`, `minute`, `hour`, `day`. Defaul
 
 The aggregation speed relies on the performance of **Redis** (data storage) and **Oj** (json serialization/parsing).
 
+#### Simple aggregation
+
 You can check the **aggregation** time by running:
 
 ```ruby
@@ -326,10 +380,10 @@ EZmetrics::Benchmark.new.measure_aggregation
 | Interval | Duration (seconds) |
 | :------: | :----------------: |
 | 1 minute |        0.0         |
-|  1 hour  |        0.04        |
-| 12 hours |        0.49        |
-| 24 hours |        1.51        |
-| 48 hours |        3.48        |
+|  1 hour  |        0.02        |
+| 12 hours |        0.22        |
+| 24 hours |        0.61        |
+| 48 hours |        1.42        |
 
 ---
 
@@ -342,9 +396,44 @@ EZmetrics::Benchmark.new.measure_aggregation(:minute)
 | Interval | Duration (seconds) |
 | :------: | :----------------: |
 | 1 minute |        0.0         |
-|  1 hour  |        0.04        |
-| 12 hours |        0.53        |
-| 24 hours |        1.59        |
-| 48 hours |        3.51        |
+|  1 hour  |        0.02        |
+| 12 hours |        0.25        |
+| 24 hours |        0.78        |
+| 48 hours |        1.75        |
+
+---
+
+#### Percentile aggregation
+
+You can check the **percentile aggregation** time by running:
+
+```ruby
+EZmetrics::Benchmark.new(true).measure_aggregation
+```
+
+| Interval | Duration (seconds) |
+| :------: | :----------------: |
+| 1 minute |        0.0         |
+|  1 hour  |        0.14        |
+| 12 hours |        2.11        |
+| 24 hours |        5.85        |
+| 48 hours |        14.1        |
+
+---
+
+To check the **partitioned aggregation** time for percentile you need to run:
+
+```ruby
+EZmetrics::Benchmark.new(true).measure_aggregation(:minute)
+```
+
+| Interval | Duration (seconds) |
+| :------: | :----------------: |
+| 1 minute |        0.0         |
+|  1 hour  |        0.16        |
+| 12 hours |        1.97        |
+| 24 hours |        5.85        |
+| 48 hours |        13.9        |
+
 
 The benchmarks above were run on a _2017 Macbook Pro 2.9 GHz Intel Core i7 with 16 GB of RAM_

data/lib/ezmetrics.rb

@@ -9,16 +9,18 @@ class EZmetrics
 
   def initialize(interval_seconds=60)
     @interval_seconds = interval_seconds.to_i
-    @redis            = Redis.new
+    @redis            = Redis.new(driver: :hiredis)
+    @schema           = redis_schema
   end
 
-  def log(payload={duration: 0.0, views: 0.0, db: 0.0, queries: 0, status: 200})
+  def log(payload={duration: 0.0, views: 0.0, db: 0.0, queries: 0, status: 200, store_each_value: false})
     @safe_payload = {
-      duration: payload[:duration].to_f,
-      views:    payload[:views].to_f,
-      db:       payload[:db].to_f,
-      queries:  payload[:queries].to_i,
-      status:   payload[:status].to_i
+      duration:         payload[:duration].to_f,
+      views:            payload[:views].to_f,
+      db:               payload[:db].to_f,
+      queries:          payload[:queries].to_i,
+      status:           payload[:status].to_i,
+      store_each_value: payload[:store_each_value].to_s == "true"
     }
 
     this_second          = Time.now.to_i
@@ -31,10 +33,11 @@ class EZmetrics
       METRICS.each do |metrics_type|
         update_sum(metrics_type)
         update_max(metrics_type)
+        store_value(metrics_type) if safe_payload[:store_each_value]
       end
 
-      this_second_metrics["statuses"]["all"]        += 1
-      this_second_metrics["statuses"][status_group] += 1
+      this_second_metrics[schema["all"]]        += 1
+      this_second_metrics[schema[status_group]] += 1
     else
       @this_second_metrics = {
         "second"       => this_second,
@@ -46,10 +49,25 @@ class EZmetrics
         "db_max"       => safe_payload[:db],
         "queries_sum"  => safe_payload[:queries],
         "queries_max"  => safe_payload[:queries],
-        "statuses"     => { "2xx" => 0, "3xx" => 0, "4xx" => 0, "5xx" => 0, "all" => 1 }
+        "2xx"          => 0,
+        "3xx"          => 0,
+        "4xx"          => 0,
+        "5xx"          => 0,
+        "all"          => 1
       }
 
-      this_second_metrics["statuses"][status_group] = 1
+      if safe_payload[:store_each_value]
+        this_second_metrics.merge!(
+          "duration_values" => [safe_payload[:duration]],
+          "views_values"    => [safe_payload[:views]],
+          "db_values"       => [safe_payload[:db]],
+          "queries_values"  => [safe_payload[:queries]]
+        )
+      end
+
+      this_second_metrics[status_group] = 1
+
+      @this_second_metrics = this_second_metrics.values
     end
 
     redis.setex(this_second, interval_seconds, Oj.dump(this_second_metrics))
@@ -70,18 +88,18 @@ class EZmetrics
 
   def partition_by(time_unit=:minute)
     time_unit = PARTITION_UNITS.include?(time_unit) ? time_unit : :minute
-    @partitioned_metrics = interval_metrics.group_by { |h| second_to_partition_unit(time_unit, h["second"]) }
+    @partitioned_metrics = interval_metrics.group_by { |array| second_to_partition_unit(time_unit, array[schema["second"]]) }
     self
   end
 
   private
 
-  attr_reader :redis, :interval_seconds, :interval_metrics, :requests, :flat,
+  attr_reader :redis, :interval_seconds, :interval_metrics, :requests, :flat, :schema,
     :storage_key, :safe_payload, :this_second_metrics, :partitioned_metrics, :options
 
   def aggregate_data
     return {} unless interval_metrics.any?
-    @requests = interval_metrics.sum { |hash| hash["statuses"]["all"] }
+    @requests = interval_metrics.sum { |array| array[schema["all"]] }
     build_result
   rescue
     {}
@@ -90,11 +108,12 @@ class EZmetrics
   def aggregate_partitioned_data
     partitioned_metrics.map do |partition, metrics|
       @interval_metrics = metrics
-      @requests = interval_metrics.sum { |hash| hash["statuses"]["all"] }
+      @requests = interval_metrics.sum { |array| array[schema["all"]] }
+      METRICS.each { |metrics_type| instance_variable_set("@sorted_#{metrics_type}_values", nil) }
       flat ? { timestamp: partition, **build_result } : { timestamp: partition, data: build_result }
     end
   rescue
-    new(options)
+    self
   end
 
   def build_result
@@ -147,39 +166,101 @@ class EZmetrics
     @interval_metrics ||= begin
       interval_start    = Time.now.to_i - interval_seconds
       interval_keys     = (interval_start..Time.now.to_i).to_a
-      redis.mget(interval_keys).compact.map { |hash| Oj.load(hash) }
+      redis.mget(interval_keys).compact.map { |array| Oj.load(array) }
     end
   end
 
   def aggregate(metrics, aggregation_function)
-    return unless AGGREGATION_FUNCTIONS.include?(aggregation_function)
     return avg("#{metrics}_sum") if aggregation_function == :avg
     return max("#{metrics}_max") if aggregation_function == :max
+
+    percentile = aggregation_function.match(/percentile_(?<value>\d+)/)
+
+    if percentile && percentile["value"]
+      sorted_values = send("sorted_#{metrics}_values")
+      percentile(sorted_values, percentile["value"].to_i)&.round
+    end
+  end
+
+  METRICS.each do |metrics|
+    define_method "sorted_#{metrics}_values" do
+      instance_variable_get("@sorted_#{metrics}_values") || instance_variable_set(
+        "@sorted_#{metrics}_values", interval_metrics.map { |array| array[schema["#{metrics}_values"]] }.flatten.compact
+      )
+    end
+  end
+
+  def redis_schema
+    [
+      "second",
+      "duration_sum",
+      "duration_max",
+      "views_sum",
+      "views_max",
+      "db_sum",
+      "db_max",
+      "queries_sum",
+      "queries_max",
+      "2xx",
+      "3xx",
+      "4xx",
+      "5xx",
+      "all",
+      "duration_values",
+      "views_values",
+      "db_values",
+      "queries_values"
+    ].each_with_index.inject({}){ |result, pair| result[pair[0]] = pair[1] ; result }
   end
 
   def update_sum(metrics)
-    this_second_metrics["#{metrics}_sum"] += safe_payload[metrics]
+    this_second_metrics[schema["#{metrics}_sum"]] += safe_payload[metrics]
+  end
+
+  def store_value(metrics)
+    this_second_metrics[schema["#{metrics}_values"]] << safe_payload[metrics]
   end
 
   def update_max(metrics)
-    max_value = [safe_payload[metrics], this_second_metrics["#{metrics}_max"]].max
-    this_second_metrics["#{metrics}_max"] = max_value
+    max_value = [safe_payload[metrics], this_second_metrics[schema["#{metrics}_max"]]].max
+    this_second_metrics[schema["#{metrics}_max"]] = max_value
   end
 
   def avg(metrics)
-    (interval_metrics.sum { |h| h[metrics] }.to_f / requests).round
+    (interval_metrics.sum { |array| array[schema[metrics]] }.to_f / requests).round
   end
 
   def max(metrics)
-    interval_metrics.max { |h| h[metrics] }[metrics].round
+    interval_metrics.max { |array| array[schema[metrics]] }[schema[metrics]].round
+  end
+
+  def percentile(array, pcnt)
+    sorted_array = array.sort
+
+    return nil if array.length == 0
+
+    rank  = (pcnt.to_f / 100) * (array.length + 1)
+    whole = rank.truncate
+
+    # if has fractional part
+    if whole != rank
+      s0 = sorted_array[whole - 1]
+      s1 = sorted_array[whole]
+
+      f = (rank - rank.truncate).abs
+
+      return (f * (s1 - s0)) + s0
+    else
+      return sorted_array[whole - 1]
+    end
   end
 
   def count_all_status_groups
-    interval_metrics.inject({ "2xx" => 0, "3xx" => 0, "4xx" => 0, "5xx" => 0 }) do |result, h|
-      result["2xx"] += h["statuses"]["2xx"]
-      result["3xx"] += h["statuses"]["3xx"]
-      result["4xx"] += h["statuses"]["4xx"]
-      result["5xx"] += h["statuses"]["5xx"]
+    interval_metrics.inject({ "2xx" => 0, "3xx" => 0, "4xx" => 0, "5xx" => 0 }) do |result, array|
+      result["2xx"] += array[schema["2xx"]]
+      result["3xx"] += array[schema["3xx"]]
+      result["4xx"] += array[schema["4xx"]]
+      result["5xx"] += array[schema["5xx"]]
       result
     end
   end

data/lib/ezmetrics/benchmark.rb

@@ -2,12 +2,13 @@ require "benchmark"
 
 class EZmetrics::Benchmark
 
-  def initialize
-    @start      = Time.now.to_i
-    @redis      = Redis.new
-    @durations  = []
-    @iterations = 3
-    @intervals  = {
+  def initialize(store_each_value=false)
+    @store_each_value = store_each_value
+    @start            = Time.now.to_i
+    @redis            = Redis.new(driver: :hiredis)
+    @durations        = []
+    @iterations       = 1
+    @intervals        = {
       "1.minute" => 60,
       "1.hour  " => 3600,
       "12.hours" => 43200,
@@ -29,31 +30,38 @@ class EZmetrics::Benchmark
 
   private
 
-  attr_reader :start, :redis, :durations, :intervals, :iterations
+  attr_reader :start, :redis, :durations, :intervals, :iterations, :store_each_value
 
   def write_metrics
     seconds = intervals.values.max
     seconds.times do |i|
       second = start - i
       payload = {
-        "second"          => second,
-        "duration_sum"    => rand(10000),
-        "duration_max"    => rand(10000),
-        "views_sum"       => rand(1000),
-        "views_max"       => rand(1000),
-        "db_sum"          => rand(8000),
-        "db_max"          => rand(8000),
-        "queries_sum"     => rand(100),
-        "queries_max"     => rand(100),
-        "statuses"        => {
-          "2xx" => rand(1..10),
-          "3xx" => rand(1..10),
-          "4xx" => rand(1..10),
-          "5xx" => rand(1..10),
-          "all" => rand(1..40)
-        }
+        "second"       => second,
+        "duration_sum" => rand(10000),
+        "duration_max" => rand(10000),
+        "views_sum"    => rand(1000),
+        "views_max"    => rand(1000),
+        "db_sum"       => rand(8000),
+        "db_max"       => rand(8000),
+        "queries_sum"  => rand(100),
+        "queries_max"  => rand(100),
+        "2xx"          => rand(1..10),
+        "3xx"          => rand(1..10),
+        "4xx"          => rand(1..10),
+        "5xx"          => rand(1..10),
+        "all"          => rand(1..40)
       }
-      redis.setex(second, seconds, Oj.dump(payload))
+
+      if store_each_value
+        payload.merge!(
+          "duration_values" => Array.new(100) { rand(10..60000) },
+          "views_values"    => Array.new(100) { rand(10..60000) },
+          "db_values"       => Array.new(100) { rand(10..60000) },
+          "queries_values"  => Array.new(10)  { rand(1..60) }
+        )
+      end
+      redis.setex(second, seconds, Oj.dump(payload.values))
     end
     nil
   end
@@ -67,10 +75,11 @@ class EZmetrics::Benchmark
   def measure_aggregation_time(interval, seconds, partition_by)
     iterations.times do
       durations << ::Benchmark.measure do
-        if partition_by
-          EZmetrics.new(seconds).partition_by(partition_by).show
+        ezmetrics = EZmetrics.new(seconds)
+        if store_each_value
+          partition_by ? ezmetrics.partition_by(partition_by).show(db: :percentile_90) : ezmetrics.show(db: :percentile_90)
         else
-          EZmetrics.new(seconds).show
+          partition_by ? ezmetrics.partition_by(partition_by).show : ezmetrics.show
         end
       end.real
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ezmetrics
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Nicolae Rotaru