ezmetrics 1.1.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 518d9350ed026801311bdc695857fdd057856f6b7fe40715bf8072c990e8e5b8
-  data.tar.gz: 7d36fbd3e63994789ce8ac04212fb44c30041fd33f7173fbfdf1a6257beea99a
+  metadata.gz: 6dca2c75bfaae789d33af8f319e5c6ff86772f480d4d2f6549f044f4bfe12586
+  data.tar.gz: 259881b87a073eaceb729b402166d185b3d66ee48af1727e27cc78a8ae5c226c
 SHA512:
-  metadata.gz: 42e990916d474ed52f08330bd7210b4c6f464a0199354cfc1fe3710817b9d57790d445d0d1f88c8fccd6daeb627638a80dd8b578c685544f6a4f9c7765522a5f
-  data.tar.gz: 5b49eec021acaef39af2c9401681fa85f02d368f36231a60a64faf595e5b0c1432ce07a67fb86ce9c8b3041835fd4480da86ea5d91f7ca0939ef5b40592e6a49
+  metadata.gz: 119325aef351ecbb8cf54a80941474904b727207ed658298f04e225bb54c99f2e47509a42f076fd1ddbe034f86d48db2b9692dbd5498c1e594903253aa4f65d6
+  data.tar.gz: fe97199f23bfac6eddf90755bfbcf74ff524b6735cf340b1dcbb625c9f66dfa4bd021733dccb7ba0d7c63aca6cb6ae6dd5523ba478fbd7ca22f1f91b33c3d661

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,13 +37,25 @@ 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
+)
 ```
 
 ```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
+)
 ```
 
 ---
@@ -41,16 +63,16 @@ You can change the timeframe according to your needs and save the metrics by cal
 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
 ```
 
 ```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
 
@@ -119,7 +141,48 @@ This will return a hash with the following structure:
 }
 ```
 
-### Aggregation options
+---
+
+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 aggregation can be easily configured by specifying aggregation options as in the following examples:
 
@@ -205,22 +268,172 @@ 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.
+
+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:
 
 ```ruby
 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.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.04        |
-| 12 hours |        0.49        |
-| 24 hours |        1.51        |
-| 48 hours |        3.48        |
+|  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,19 +5,22 @@ 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
+    @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
@@ -30,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],
@@ -44,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))
@@ -57,28 +77,51 @@ class EZmetrics
   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
-    @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.sum { |hash| hash["statuses"]["all"] }
+  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 = {}
 
-    result[:requests] = { all: requests, grouped: count_all_status_groups } if options[:requests]
+    if options[:requests]
+      append_requests_to_result(result, { all: requests, grouped: count_all_status_groups })
+    end
 
     options.each do |metrics, aggregation_functions|
       next unless METRICS.include?(metrics)
@@ -86,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
@@ -95,35 +138,129 @@ 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") 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,
@@ -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,30 +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 = {
-        "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(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
@@ -63,9 +72,16 @@ class EZmetrics::Benchmark
     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.1
+  version: 2.0.1
 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: []