ezmetrics 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ba2e24bca76b2786c1264b779e72764e123094150855cae241d673505df95ad
-  data.tar.gz: 3c297b92a53c51b8b881fbbafb15929b9bac36eb53164c3faab37c2caa72db02
+  metadata.gz: 16333a0b9644e92d3f3648530e2217d6cc76eb2c427a63cf315d254f2e081cb6
+  data.tar.gz: 5dc280c1ec8594856addced752296731f9dfdc9ad7bae84625541d959f50f2d7
 SHA512:
-  metadata.gz: 4d1e8118d48cac15dca166c6c4f0d8e38344b28bfcc85343fa87ff4877d34bc7f12b9841241de563723261df5a48210cf1838c09eece3bc15d5f2dde6a58c8c2
-  data.tar.gz: 8e62b7b53f73a6343c8fd6f11e0e8a9f856314dd262c10611cd9bf061636c8801255de58818a1736069679525bed73c949e6f61778910de8a306da30c352e2a2
+  metadata.gz: 48c142669ed79439784f8ed4c12d658169a51b125c2dbfd9e1324271d388fc69df3fe6c960b73970898ab088ca000335a405877c44722f717c38b2169a7c0bc4
+  data.tar.gz: c2503cd1900b0723db05e72dae3ee3c7633e46dabde7083f218fae8e0c3354c78edf1ab549b7e308d356017b171dc24da540d93fa4fe1b067f948de8df02e521

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/ezmetrics.svg)](https://badge.fury.io/rb/ezmetrics)
 
-A simple tool for capturing and displaying Rails metrics.
+Simple, lightweight and fast metrics aggregation for Rails.
 
 ## Installation
 
@@ -10,6 +10,16 @@ A simple tool for capturing and displaying Rails metrics.
 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
@@ -27,32 +37,42 @@ and stores them for the timeframe you specified, 60 seconds by default.
 You can change the timeframe according to your needs and save the metrics by calling `log` method:
 
 ```ruby
-  # Store the metrics for 60 seconds (default behaviour)
-  EZmetrics.new.log(duration: 100.5, views: 40.7, db: 59.8, queries: 4, status: 200)
+# Store the metrics for 60 seconds (default behaviour)
+EZmetrics.new.log(
+  duration: 100.5,
+  views:    40.7,
+  db:       59.8,
+  queries:  4,
+  status:   200
+)
 ```
 
-or
-
 ```ruby
-  # Store the metrics for 10 minutes
-  EZmetrics.new(10.minutes).log(duration: 100.5, views: 40.7, db: 59.8, queries: 4, status: 200)
+# Store the metrics for 10 minutes
+EZmetrics.new(10.minutes).log(
+  duration: 100.5,
+  views:    40.7,
+  db:       59.8,
+  queries:  4,
+  status:   200
+)
 ```
 
-For displaying metrics you need call `show` method:
+---
+
+For displaying metrics you need to call `show` method:
 
 ```ruby
-  # Aggregate and show metrics for last 60 seconds (default behaviour)
-  EZmetrics.new.show
+# Aggregate and show metrics for last 60 seconds (default behaviour)
+EZmetrics.new.show
 ```
 
-or
-
 ```ruby
-  # Aggregate and show metrics for last 10 minutes
-  EZmetrics.new(10.minutes).show
+# Aggregate and show metrics for last 10 minutes
+EZmetrics.new(10.minutes).show
 ```
 
-> Please note that you can combine these timeframes, for example - store for 10 minutes, display for 5 minutes.
+You can combine these timeframes, for example - store for 10 minutes, display for 5 minutes.
 
 ### Capture metrics
 
@@ -121,11 +141,52 @@ This will return a hash with the following structure:
 }
 ```
 
-### Output configuration
+---
+
+If you prefer a single level object - you can change the default output structure by calling `.flatten` before `.show`
+
+```ruby
+EZmetrics.new(1.hour).flatten.show(db: :avg, duration: [:avg, :max])
+```
+
+```ruby
+{
+  db_avg:       182,
+  duration_avg: 205,
+  duration_max: 5171
+}
+```
+
+---
+
+Same for [partitioned aggregation](#partitioning)
+
+```ruby
+EZmetrics.new(1.hour).partition_by(:minute).flatten.show(db: :avg, duration: [:avg, :max])
+```
+
+```ruby
+[
+  {
+    timestamp:    1575242880,
+    db_avg:       387,
+    duration_avg: 477,
+    duration_max: 8566
+  },
+  {
+    timestamp:    1575242940,
+    db_avg:       123,
+    duration_avg: 234,
+    duration_max: 3675
+  }
+]
+```
+
+### Aggregation
 
-The output can be easily configured by specifying aggregation options as in the following examples:
+The aggregation can be easily configured by specifying aggregation options as in the following examples:
 
-1. Single
+**1. Single**
 
 ```ruby
 EZmetrics.new.show(duration: :max)
@@ -139,7 +200,9 @@ EZmetrics.new.show(duration: :max)
 }
 ```
 
-2. Multiple
+---
+
+**2. Multiple**
 
 ```ruby
 EZmetrics.new.show(queries: [:max, :avg])
@@ -154,7 +217,9 @@ EZmetrics.new.show(queries: [:max, :avg])
 }
 ```
 
-3. Requests
+---
+
+**3. Requests**
 
 ```ruby
 EZmetrics.new.show(requests: true)
@@ -174,7 +239,9 @@ EZmetrics.new.show(requests: true)
 }
 ```
 
-4. Combined
+---
+
+**4. Combined**
 
 ```ruby
 EZmetrics.new.show(views: :avg, :db: [:avg, :max], requests: true)
@@ -201,15 +268,108 @@ EZmetrics.new.show(views: :avg, :db: [:avg, :max], requests: true)
 }
 ```
 
-### Performance
+---
+
+**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
+  }
+}
+```
 
-The implementation is based on **Redis** commands such as:
 
-- [`get`](https://redis.io/commands/get)
-- [`mget`](https://redis.io/commands/mget)
-- [`setex`](https://redis.io/commands/setex)
+### Partitioning
 
-which are extremely fast.
+If you want to visualize your metrics by using a **line chart**, you will need to use partitioning.
+
+To aggregate metrics, partitioned by a unit of time you need to call `.partition_by({time_unit})` before calling `.show`
+
+```ruby
+# Aggregate metrics for last hour, partition by minute
+EZmetrics.new(1.hour).partition_by(:minute).show(duration: [:avg, :max], db: :avg)
+```
+
+This will return an array of objects with the following structure:
+
+```ruby
+[
+  {
+    timestamp: # UNIX timestamp
+    data:      # a hash with aggregated metrics
+  }
+]
+```
+
+like in the example below:
+
+```ruby
+[
+  {
+    timestamp: 1575242880,
+    data: {
+      duration: {
+        avg: 477,
+        max: 8566
+      },
+      db: {
+        avg: 387
+      }
+    }
+  },
+  {
+    timestamp: 1575242940,
+    data: {
+      duration: {
+        avg: 234,
+        max: 3675
+      },
+      db: {
+        avg: 123
+      }
+    }
+  }
+]
+```
+
+Available time units for partitioning: `second`, `minute`, `hour`, `day`. Default: `minute`.
+
+### Performance
+
+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:
 
@@ -217,12 +377,63 @@ You can check the **aggregation** time by running:
 EZmetrics::Benchmark.new.measure_aggregation
 ```
 
-The result of running this benchmark on a _2017 Macbook Pro 2.9 GHz Intel Core i7 with 16 GB of RAM_:
+| Interval | Duration (seconds) |
+| :------: | :----------------: |
+| 1 minute |        0.0         |
+|  1 hour  |        0.02        |
+| 12 hours |        0.22        |
+| 24 hours |        0.61        |
+| 48 hours |        1.42        |
+
+---
+
+To check the **partitioned aggregation** time you need to run:
+
+```ruby
+EZmetrics::Benchmark.new.measure_aggregation(:minute)
+```
 
 | Interval | Duration (seconds) |
 | :------: | :----------------: |
 | 1 minute |        0.0         |
-|  1 hour  |        0.05        |
-| 12 hours |        0.66        |
-| 24 hours |        1.83        |
-| 48 hours |        4.06        |
+|  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

@@ -5,25 +5,27 @@ require "oj"
 class EZmetrics
   METRICS               = [:duration, :views, :db, :queries].freeze
   AGGREGATION_FUNCTIONS = [:max, :avg].freeze
+  PARTITION_UNITS       = [:second, :minute, :hour, :day].freeze
 
   def initialize(interval_seconds=60)
     @interval_seconds = interval_seconds.to_i
-    @redis            = Redis.new
-    @storage_key      = "ez-metrics"
+    @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
     status_group         = "#{payload[:status].to_s[0]}xx"
-    @this_second_metrics = redis.get("#{storage_key}:#{this_second}")
+    @this_second_metrics = redis.get(this_second)
 
     if this_second_metrics
       @this_second_metrics = Oj.load(this_second_metrics)
@@ -31,12 +33,14 @@ 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,
         "duration_sum" => safe_payload[:duration],
         "duration_max" => safe_payload[:duration],
         "views_sum"    => safe_payload[:views],
@@ -45,50 +49,78 @@ 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("#{storage_key}:#{this_second}", interval_seconds, Oj.dump(this_second_metrics))
+    redis.setex(this_second, interval_seconds, Oj.dump(this_second_metrics))
     true
   rescue => error
     formatted_error(error)
   end
 
   def show(options=nil)
-    @options          = options || default_options
-    interval_start    = Time.now.to_i - interval_seconds
-    interval_keys     = (interval_start..Time.now.to_i).to_a.map { |second| "#{storage_key}:#{second}" }
-    @interval_metrics = redis.mget(interval_keys).compact.map { |hash| Oj.load(hash) }
+    @options = options || default_options
+    partitioned_metrics ? aggregate_partitioned_data : aggregate_data
+  end
 
-    return {} unless interval_metrics.any?
+  def flatten
+    @flat = true
+    self
+  end
 
-    @requests = interval_metrics.map { |hash| hash["statuses"]["all"] }.compact.sum
+  def partition_by(time_unit=:minute)
+    time_unit = PARTITION_UNITS.include?(time_unit) ? time_unit : :minute
+    @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, :schema,
+    :storage_key, :safe_payload, :this_second_metrics, :partitioned_metrics, :options
+
+  def aggregate_data
+    return {} unless interval_metrics.any?
+    @requests = interval_metrics.sum { |array| array[schema["all"]] }
     build_result
   rescue
     {}
   end
 
-  private
-
-  attr_reader :redis, :interval_seconds, :interval_metrics, :requests,
-    :storage_key, :safe_payload, :this_second_metrics, :options
+  def aggregate_partitioned_data
+    partitioned_metrics.map do |partition, metrics|
+      @interval_metrics = metrics
+      @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
+    self
+  end
 
   def build_result
     result = {}
 
     if options[:requests]
-      result[:requests] = {
-        all: requests,
-        grouped: {
-          "2xx" => count("2xx"),
-          "3xx" => count("3xx"),
-          "4xx" => count("4xx"),
-          "5xx" => count("5xx")
-        }
-      }
+      append_requests_to_result(result, { all: requests, grouped: count_all_status_groups })
     end
 
     options.each do |metrics, aggregation_functions|
@@ -97,8 +129,8 @@ class EZmetrics
       next unless aggregation_functions.any?
 
       aggregation_functions.each do |aggregation_function|
-        result[metrics] ||= {}
-        result[metrics][aggregation_function] = aggregate(metrics, aggregation_function)
+        aggregated_metrics = aggregate(metrics, aggregation_function)
+        append_metrics_to_result(result, metrics, aggregation_function, aggregated_metrics)
       end
     end
     result
@@ -106,31 +138,131 @@ class EZmetrics
     result
   end
 
+  def append_requests_to_result(result, aggregated_requests)
+    return result[:requests] = aggregated_requests unless flat
+
+    result[:requests_all] = aggregated_requests[:all]
+    aggregated_requests[:grouped].each do |group, counter|
+      result[:"requests_#{group}"] = counter
+    end
+  end
+
+  def append_metrics_to_result(result, metrics, aggregation_function, aggregated_metrics)
+    return result[:"#{metrics}_#{aggregation_function}"] = aggregated_metrics if flat
+
+    result[metrics] ||= {}
+    result[metrics][aggregation_function] = aggregated_metrics
+  end
+
+  def second_to_partition_unit(time_unit, second)
+    return second if time_unit == :second
+    time = Time.at(second)
+    return (time - time.sec - time.min * 60 - time.hour * 3600).to_i if time_unit == :day
+    return (time - time.sec - time.min * 60).to_i                    if time_unit == :hour
+    (time - time.sec).to_i
+  end
+
+  def interval_metrics
+    @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 { |array| Oj.load(array) }
+    end
+  end
+
   def aggregate(metrics, aggregation_function)
-    return unless AGGREGATION_FUNCTIONS.include?(aggregation_function)
-    return avg("#{metrics}_sum".to_sym) if aggregation_function == :avg
-    return max("#{metrics}_max".to_sym) if aggregation_function == :max
+    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.to_sym]
+    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.to_sym], 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.map { |h| h[metrics.to_s] }.sum.to_f / requests).round
+    (interval_metrics.sum { |array| array[schema[metrics]] }.to_f / requests).round
   end
 
   def max(metrics)
-    interval_metrics.map { |h| h[metrics.to_s] }.max.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(group)
-    interval_metrics.map { |h| h["statuses"][group.to_s] }.sum
+  def count_all_status_groups
+    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
 
   def default_options

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,
@@ -16,11 +17,11 @@ class EZmetrics::Benchmark
     }
   end
 
-  def measure_aggregation
+  def measure_aggregation(partition_by=nil)
     write_metrics
     print_header
     intervals.each do |interval, seconds|
-      result = measure_aggregation_time(interval, seconds)
+      result = measure_aggregation_time(interval, seconds, partition_by)
       print_row(result)
     end
     cleanup_metrics
@@ -29,43 +30,58 @@ 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 = {
-        "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(10),
-          "3xx" => rand(10),
-          "4xx" => rand(10),
-          "5xx" => rand(10),
-          "all" => rand(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("ez-metrics:#{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
 
   def cleanup_metrics
     interval_start = Time.now.to_i - intervals.values.max - 100
-    interval_keys  = (interval_start..Time.now.to_i).to_a.map { |second| "ez-metrics:#{second}" }
+    interval_keys  = (interval_start..Time.now.to_i).to_a
     redis.del(interval_keys)
   end
 
-  def measure_aggregation_time(interval, seconds)
+  def measure_aggregation_time(interval, seconds, partition_by)
     iterations.times do
-      durations << ::Benchmark.measure { EZmetrics.new(seconds).show }.real
+      durations << ::Benchmark.measure do
+        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
+          partition_by ? ezmetrics.partition_by(partition_by).show : ezmetrics.show
+        end
+      end.real
     end
 
     return {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ezmetrics
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Nicolae Rotaru
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
-description: A simple tool for capturing and displaying Rails metrics.
+description: Simple, lightweight and fast metrics aggregation for Rails.
 email: nyku.rn@gmail.com
 executables: []
 extensions: []