gremlin 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96d4a7c502789e7253b18116cb7f0ec78f723d87
-  data.tar.gz: 79abfbd5b0389284cea77f479c8251bc150f2808
+  metadata.gz: 76f9c1702a54c108247ab988504f59efb41a0736
+  data.tar.gz: 739424d848af9ff260de7ba34d78addb6a77f89d
 SHA512:
-  metadata.gz: ac3351e8bc6f3a26ca5e56682774e9d89460c26624cc6601f32ff1bed0d75c8735ae321aa5b571b6c38276f9b122f3977eef099d4e6ddf61030cab380e11f103
-  data.tar.gz: 74382b4281f6665f900639bc89480cdba8b88c09ed54eef140af923302ace24b69cb699018f90b14c9b289185120670b7e8149d9b66ff4cc9898c9a53baa33c2
+  metadata.gz: cacbcc4da37f36e33167541c6958005e31f8dee7b7bf8f7c21d464deb7fe566313092c7b0fbdf93a2809967b65b523f333235cea42155db5252d0cc6dbe696b6
+  data.tar.gz: 0562dee3d4491516df49a0f4bd6f17d59d6a4ab59207c259663cdeae21901edae05da79431d1957591cb923481fe3eaca5ee8b5724d2e38f133723baa9b98d34

data/.gitignore

@@ -1,4 +1,12 @@
+.bundle/
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
 *.sw*
 spec/examples.txt
 *.gem
 *.rdb
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+gremlin

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    gremlin (0.0.3)
+    gremlin (0.0.4)
       quantile
       rails
       redis (~> 3.2)
-      redis-native_hash
 
 GEM
   remote: https://rubygems.org/
@@ -96,10 +95,8 @@ GEM
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)
     rake (10.5.0)
-    rdoc (5.0.0)
+    rdoc (5.1.0)
     redis (3.3.3)
-    redis-native_hash (0.2.1)
-      redis (>= 2.0.0)
     rspec (3.5.0)
       rspec-core (~> 3.5.0)
       rspec-expectations (~> 3.5.0)
@@ -112,6 +109,14 @@ GEM
     rspec-mocks (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.5.0)
+    rspec-rails (3.5.2)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+      rspec-support (~> 3.5.0)
     rspec-support (3.5.0)
     sprockets (3.7.1)
       concurrent-ruby (~> 1.0)
@@ -120,6 +125,7 @@ GEM
       actionpack (>= 4.0)
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
+    sqlite3 (1.3.13)
     thor (0.19.4)
     thread_safe (0.3.6)
     tzinfo (1.2.2)
@@ -137,6 +143,8 @@ DEPENDENCIES
   rake (~> 10.0)
   rdoc
   rspec (~> 3.3, >= 3.3.0)
+  rspec-rails
+  sqlite3
 
 BUNDLED WITH
-   1.12.4
+   1.14.5

data/README.md

@@ -2,8 +2,6 @@
 
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gremlin`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-TODO: Delete this and the text above, and describe your gem
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -32,10 +30,13 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gremlin.
+Bug reports and pull requests are welcome on GitHub at https://github.com/omadahealth/gremlin.
 
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+## Resources
+
+https://speakerdeck.com/nextmat/digging-deep-with-activesupportnotifications

data/app/controllers/gremlin/metrics_controller.rb

@@ -8,7 +8,7 @@ module Gremlin
       registry = Gremlin.registry
 
       metrics = registry.metrics.map do |metric|
-        metric.repr
+        metric.repr_and_delete
       end
 
       plaintext(metrics)

data/benchmark.rb

@@ -1,5 +1,6 @@
 require 'benchmark'
 require 'gremlin'
+require 'securerandom'
 
 
 include Benchmark
@@ -8,15 +9,16 @@ print "Starting benchmarks..."
 
 orig_std_out = STDOUT.clone
 STDOUT.reopen(File::open('/dev/null', 'w'))
+iterations = ARGV[-1].to_i
 
-counter_init_benchmarks = (1..100).map do |n|
+counter_init_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         counter_name = "test_#{SecureRandom.hex(5)}_counter".to_sym
         x.report("Counter initialize") { Gremlin::Instruments::Counter.new counter_name, "placeholder", {} }
     end
 end
 
-counter_init_and_fetch_benchmarks = (1..100).map do |n|
+counter_init_and_fetch_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         counter_name = "test_#{SecureRandom.hex(5)}_counter".to_sym
         x.report("Counter initialize then fetch") do
@@ -26,7 +28,7 @@ counter_init_and_fetch_benchmarks = (1..100).map do |n|
     end
 end
 
-counter_init_and_incr_benchmarks = (1..100).map do |n|
+counter_init_and_incr_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         counter_name = "test_#{SecureRandom.hex(5)}_counter".to_sym
         x.report("Counter increment") do
@@ -36,7 +38,7 @@ counter_init_and_incr_benchmarks = (1..100).map do |n|
     end
 end
 
-gauge_init_benchmarks = (1..100).map do |n|
+gauge_init_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         gauge_name = "test_#{SecureRandom.hex(5)}_gauge".to_sym
         gauge_set_val = rand(1..25000000)
@@ -44,7 +46,7 @@ gauge_init_benchmarks = (1..100).map do |n|
     end
 end
 
-gauge_init_and_fetch_benchmarks = (1..100).map do |n|
+gauge_init_and_fetch_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         gauge_name = "test_#{SecureRandom.hex(5)}_gauge".to_sym
         gauge_set_val = rand(1..25000000)
@@ -55,7 +57,7 @@ gauge_init_and_fetch_benchmarks = (1..100).map do |n|
     end
 end
 
-gauge_init_and_set_benchmarks = (1..100).map do |n|
+gauge_init_and_set_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         gauge_name = "test_#{SecureRandom.hex(5)}_gauge".to_sym
         gauge_set_val = rand(1..25000000)
@@ -66,7 +68,7 @@ gauge_init_and_set_benchmarks = (1..100).map do |n|
     end
 end
 
-summary_init_benchmarks = (1..100).map do |n|
+summary_init_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         summary_name = "test_#{SecureRandom.hex(5)}_summary".to_sym
         summary_observe_val = rand(1..25000000)
@@ -74,7 +76,7 @@ summary_init_benchmarks = (1..100).map do |n|
     end
 end
 
-summary_init_and_fetch_benchmarks = (1..100).map do |n|
+summary_init_and_fetch_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         summary_name = "test_#{SecureRandom.hex(5)}_summary".to_sym
         summary_observe_val = rand(1..25000000)
@@ -85,13 +87,15 @@ summary_init_and_fetch_benchmarks = (1..100).map do |n|
     end
 end
 
-summary_init_and_observe_benchmarks = (1..100).map do |n|
+summary_init_and_observe_benchmarks = (1..iterations).map do |n|
     Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
         summary_name = "test_#{SecureRandom.hex(5)}_summary".to_sym
         summary_observe_val = rand(1..25000000)
         x.report("Summary observe") do 
             summary = Gremlin::Instruments::Summary.new summary_name.to_sym, "placeholder", {}
-            summary.observe({ :bar => "foo" }, summary_observe_val)
+            (1..iterations).each do
+              summary.observe({ :bar => "foo" }, summary_observe_val)
+            end
         end
     end
 end
@@ -106,11 +110,11 @@ counter_init_and_fetch_agg = counter_init_and_fetch_benchmarks.flatten.inject(0)
 puts "--------------------------------------------------------"
 puts ""
 puts "Counter Initialize Total:             #{counter_init_agg*1000} ms"
-puts "Counter Initialize Avg:               #{counter_init_agg/100*1000} ms over 100 iterations"
+puts "Counter Initialize Avg:               #{counter_init_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Counter Initialize and Fetch Total:   #{counter_init_and_fetch_agg*1000} ms"
-puts "Counter Initialize and Fetch Avg:     #{counter_init_and_fetch_agg/100*1000} ms over 100 iterations"
+puts "Counter Initialize and Fetch Avg:     #{counter_init_and_fetch_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Counter Initialize and Fetch Total:   #{counter_init_and_incr_agg*1000} ms"
-puts "Counter Initialize and Fetch Avg:     #{counter_init_and_incr_agg/100*1000} ms over 100 iterations"
+puts "Counter Initialize and Fetch Avg:     #{counter_init_and_incr_agg/iterations*1000} ms over #{iterations} iterations"
 puts ""
 
 gauge_init_agg           = gauge_init_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
@@ -120,11 +124,11 @@ gauge_init_and_set_agg   = gauge_init_and_set_benchmarks.flatten.inject(0) { |su
 puts "--------------------------------------------------------"
 puts ""
 puts "Gauge Initialize Total:               #{gauge_init_agg*1000} ms"
-puts "Gauge Initialize Avg:                 #{gauge_init_agg/100*1000} ms over 100 iterations"
+puts "Gauge Initialize Avg:                 #{gauge_init_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Gauge Initialize and Fetch Total:     #{gauge_init_and_fetch_agg*1000} ms"
-puts "Gauge Initialize and Fetch Avg:       #{gauge_init_and_fetch_agg/100*1000} ms over 100 iterations"
+puts "Gauge Initialize and Fetch Avg:       #{gauge_init_and_fetch_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Gauge Initialize and Set Total:       #{gauge_init_and_set_agg*1000} ms"
-puts "Gauge Initialize and Set Avg:         #{gauge_init_and_set_agg/100*1000} ms over 100 iterations"
+puts "Gauge Initialize and Set Avg:         #{gauge_init_and_set_agg/iterations*1000} ms over #{iterations} iterations"
 puts ""
 puts "--------------------------------------------------------"
 
@@ -134,10 +138,10 @@ summary_init_and_observe_agg   = summary_init_and_observe_benchmarks.flatten.inj
 
 puts ""
 puts "Summary Initialize Total:             #{summary_init_agg*1000} ms"
-puts "Summary Initialize Avg:               #{summary_init_agg/100*1000} ms over 100 iterations"
+puts "Summary Initialize Avg:               #{summary_init_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Summary Initialize and Fetch Total:   #{summary_init_and_fetch_agg*1000} ms"
-puts "Summary Initialize and Fetch Avg:     #{summary_init_and_fetch_agg/100*1000} ms over 100 iterations"
+puts "Summary Initialize and Fetch Avg:     #{summary_init_and_fetch_agg/iterations*1000} ms over #{iterations} iterations"
 puts "Summary Initialize and Observe Total: #{summary_init_and_observe_agg*1000} ms"
-puts "Summary Initialize and Observe Avg:   #{summary_init_and_observe_agg/100*1000} ms over 100 iterations"
+puts "Summary Initialize and Observe Avg:   #{summary_init_and_observe_agg/(iterations*iterations)*1000} ms over #{iterations} observations with #{iterations} iterations"
 puts ""
 puts "--------------------------------------------------------"

data/bin/rails

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/gremlin/engine', __FILE__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/gremlin.gemspec

@@ -6,7 +6,7 @@ require 'gremlin/version'
 Gem::Specification.new do |spec|
   spec.name          = "gremlin"
   spec.version       = Gremlin::VERSION
-  spec.authors       = ["Kevin G. Phillips"]
+  spec.authors       = ["Kevin G. Phillips", "Chris Constantine"]
   spec.email         = ["platform@omadahealth.com"]
 
   spec.summary       = %q{Gem to sanely emit metrics from Omadahealth rails applications}
@@ -31,8 +31,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency 'rspec', '~> 3.3', '>= 3.3.0'
   spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "sqlite3"
 
-  spec.add_runtime_dependency 'redis-native_hash'
   spec.add_runtime_dependency 'quantile'
   spec.add_runtime_dependency 'rails'
   spec.add_runtime_dependency 'redis', '~> 3.2'

data/lib/gremlin.rb

@@ -1,10 +1,11 @@
 # Supporting librarires
 require "active_support/cache"
 require "active_support/notifications" if defined?(::Rails)
+require "active_support/subscriber" if defined?(::Rails)
 require "erb"
 require "json"
 require "quantile"
-require "redis_hash"
+require "redis"
 require "yaml"
 
 # Gem internals

data/lib/gremlin/instruments.rb

@@ -7,14 +7,39 @@ module Gremlin
         @name = name
         @docstring = docstring
         @base_labels = base_labels
-        @mutex = Mutex.new
 
         @r = Redis.new(**Gremlin.configuration.redis)
-        Redis::NativeHash.redis = @r
-        @values = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new
-        #@values.redis = Redis::NativeHash.redis
-        @values.key = retention_key
-        @values.save
+      end
+
+      def delete
+        @r.del retention_key
+      end
+
+      def retention_get
+        @r.hgetall retention_key
+      end
+
+      def parse(value)
+        {
+          name: @name,
+          type: type_string,
+          help: help_string,
+          values: value.each_with_object({}) { |(l,v), m| m[JSON.parse(l).merge(@base_labels)] = cast(v) }
+        }
+      end
+
+      def repr
+        parse(retention_get)
+      end
+
+      def repr_and_delete
+        val = nil
+        @r.pipelined do
+          val = retention_get
+          @r.del retention_key
+        end
+        v = parse(val.value)
+        return v
       end
 
       def node
@@ -33,10 +58,6 @@ module Gremlin
         "# TYPE #{@name} #{type}"
       end
 
-      def default
-        nil
-      end
-
       def help
         @docstring
       end
@@ -45,27 +66,20 @@ module Gremlin
         "# HELP #{@name} #{help}"
       end
 
-      def repr
-        {
-          name: @name,
-          type: type_string,
-          help: help_string,
-          values: values.each_with_object({}) { |(l,v), m| m[l.merge(@base_labels)] = v }
-        }
+      def cast(v)
+        case type
+        when :counter
+          v.to_i
+        when :gauge
+          v.to_f
+        else
+          v
+        end
       end
 
       def values
-        @mutex.synchronize do
-          @values.each_with_object({}) do |(labels, value), memo|
-            case type
-            when :counter
-              memo[JSON.parse(labels)] = value.to_i
-            when :gauge
-              memo[JSON.parse(labels)] = value.to_f
-            else
-              memo[JSON.parse(labels)] = value
-            end
-          end
+        retention_get.each_with_object({}) do |(labels, value), memo|
+          memo[JSON.parse(labels)] = cast(value)
         end
       end
     end

data/lib/gremlin/instruments/counter.rb

@@ -4,9 +4,7 @@ module Gremlin
   module Instruments
     class Counter < Base
       def increment(labels={}, by=1)
-        @mutex.synchronize do
-          @r.hincrby retention_key, labels.to_json, by
-        end
+        @r.hincrby retention_key, labels.to_json, by
       end
 
       def default
@@ -22,9 +20,8 @@ module Gremlin
       end
 
       def get(labels={})
-        @values.reload!
-        v = @values[labels.to_json]
-        v.to_i
+        v = retention_get[labels.to_json]
+        cast(v)
       end
     end
   end

data/lib/gremlin/instruments/gauge.rb

@@ -4,10 +4,8 @@ module Gremlin
   module Instruments
     class Gauge < Base
       def set(labels={}, value)
-        @mutex.synchronize do
-          @r.hset retention_key, labels.to_json, value
-          get(labels)
-        end
+        @r.hset retention_key, labels.to_json, value
+        get(labels)
       end
 
       def type
@@ -19,9 +17,8 @@ module Gremlin
       end
 
       def get(labels={})
-        @values.reload!
-        v = @values[labels.to_json]
-        v.to_f
+        v = retention_get[labels.to_json]
+        cast(v)
       end
     end
   end

data/lib/gremlin/instruments/summary.rb

@@ -6,68 +6,68 @@ module Gremlin
       class Value < Hash
         def initialize(estimator)
           @sum = estimator.sum
-          @total = estimator.observations
 
-          estimator.invariants.each do |invariant|
-            self[invariant.quantile] = estimator.query(invariant.quantile)
+          estimator.values.each do |percent, value|
+            self[percent] = value
           end
         end
       end
 
       def observe(labels={}, value)
-        @mutex.synchronize do
-          e = @values[labels.to_json]
-
-          if e.nil?
-            estimator = default
-          else
-            deserialized = JSON.parse(e)
-            estimator = unpack(deserialized)
-          end
-          sum = estimator.observe(value)
-
-          @values[labels.to_json] = estimator.serialize
-          @values.save
-
-          sum
-        end
+        # grabbing estimator from redis
+        # deserializing and converting back to objects
+        # adding a new observation into the values array
+        # set the updated estimator into redis
+        # return sum
+        # if retention_get == {}
+        #   e = nil
+        # else
+        #   e = parse(retention_get)[labels.to_json]
+        # end
+        #
+        # if e.nil?
+        #   estimator = default
+        # else
+        #   deserialized = JSON.parse(e)
+        #   estimator = unpack(deserialized)
+        # end
+        # sum = estimator.observe(value)
+        #
+        # @r.hset retention_key, labels.to_json, p(estimator.serialize)
+        #
+        # sum
+
+        estimator = Gremlin::Quantile::Estimator.deserialize(retention_get[labels.to_json])
+        sum = estimator.observe(value)
+        @r.hset retention_key, labels.to_json, estimator.serialize
+        sum
       end
 
       def values
-        @mutex.synchronize do
-          @values.each_with_object({}) do |(labels, value), memo|
-            deserialized = JSON.parse(value)
-            e = unpack(deserialized)
-            memo[JSON.parse(labels)] = Value.new(e)
-          end
+        retention_get.each_with_object({}) do |(labels, value), memo|
+          deserialized = JSON.parse(value)
+          e = unpack(deserialized)
+          memo[JSON.parse(labels)] = Value.new(e)
         end
       end
 
       def get(labels={})
-        @mutex.synchronize do
-          val = @values[labels.to_json]
-          return val if val.nil?
+        val = retention_get[labels.to_json]
+        return val if val.nil?
 
-          deserialized = JSON.parse(val)
-          Value.new(unpack(deserialized))
-        end
+        deserialized = JSON.parse(val)
+        Value.new(unpack(deserialized))
       end
 
-      def unpack(metric_hash)
-        Gremlin::Quantile::Estimator.new(metric_hash["buffer"],
-                                       metric_hash["head"],
-                                       metric_hash["observations"].to_i,
-                                       metric_hash["sum"].to_f,
-                                       *metric_hash["invariants"].map { |i| Gremlin::Quantile::Quantile.new i["quantile"], i["inaccuracy"] })
-      end
-
-      def repr
-        vals = values.each_with_object({}) { |(l,v), m| m[l.merge(@base_labels)] = v }
+      def parse(value)
+        vals = value.each_with_object({}) { |(l,v), m| m[JSON.parse(l).merge(@base_labels)] = cast(v) }
 
-        values = vals.each_with_object({}) do |(labels, value), memo|
-          if value.is_a? Hash
-            value.each do |b, i|
-              memo[labels.merge({quantile: b})] = i
+        values = vals.each_with_object({}) do |(l, v), memo|
+          v = JSON.parse(v)
+          if v.is_a? Hash
+            v = Value.new(unpack(v))
+            v.each do |b, i|
+              memo[l.merge({percent: b})] = i
             end
           end
         end
@@ -80,6 +80,11 @@ module Gremlin
         }
       end
 
+      def unpack(metric_hash)
+        Gremlin::Quantile::Estimator.new(values: metric_hash["values"],
+                                       invariants: metric_hash["invariants"].map { |i| Gremlin::Quantile::Percentile.new(i["percent"]) })
+      end
+
       def default
         Gremlin::Quantile::Estimator.new
       end

data/lib/gremlin/quantile.rb

@@ -1,5 +1,5 @@
 require 'gremlin/quantile/estimator'
-require 'gremlin/quantile/quantile'
+require 'gremlin/quantile/percentile'
 
 module Gremlin
   module Quantile

data/lib/gremlin/quantile/estimator.rb

@@ -1,27 +1,46 @@
 module Gremlin
   module Quantile
-    class Estimator < ::Quantile::Estimator
-      def initialize(buffer=[], head=nil, observations=0, sum=0, *invariants)
-        if invariants.empty?
-          invariants = [Gremlin::Quantile::Quantile.new(0.5, 0.05), Gremlin::Quantile::Quantile.new(0.9, 0.01), Gremlin::Quantile::Quantile.new(0.99, 0.001)]
+    class Estimator
+
+      attr_accessor :invariants
+
+      def initialize(values: nil, invariants: nil)
+        if invariants.nil?
+          invariants = [Gremlin::Quantile::Percentile.new(0.5), Gremlin::Quantile::Percentile.new(0.9), Gremlin::Quantile::Percentile.new(0.99)]
         end
 
         @invariants = invariants
-        @buffer = buffer
-        @head = head
-        @observations = observations
-        @sum = sum
+        @values = values || []
+      end
+
+      def observe(value)
+        @values << value
+        sum
+      end
+
+      def sum
+        @values.reduce { |sum, x| sum += x }
+      end
+
+      def values
+        @values.sort!
+        invariants.inject(Hash.new) do |doc, invariant|
+          doc[invariant.percent] = invariant.calculate(@values)
+          doc
+        end
       end
 
       def serialize
         JSON.dump({
-          invariants: @invariants.map { |i| i.to_h },
-          buffer: @buffer,
-          head: @head,
-          sum: @sum,
-          observations: @observations
+            invariants: @invariants.map { |i| i.to_h },
+            values: @values
         })
       end
+
+      def self.deserialize(message)
+        doc = JSON.parse(message || "{}")
+        new(values: doc["values"], invariants: doc["invariants"])
+      end
     end
   end
 end

data/lib/gremlin/quantile/percentile.rb

@@ -0,0 +1,26 @@
+module Gremlin
+  module Quantile
+    class Percentile
+      attr_accessor :percent
+
+      def initialize(percent)
+        @percent = percent
+        raise unless @percent
+      end
+
+      def to_h
+        {
+          percent: @percent,
+        }
+      end
+
+      def calculate(sorted_values)
+        sorted_values[(@percent * sorted_values.count).to_i]
+      end
+
+      def serialize
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/gremlin/railtie.rb

@@ -1,39 +1,4 @@
-module Gremlin
-   module ActionController
-    class StartProcessingCounterReceiver < Gremlin::NotificationObserver::CounterReceiver
-      def call(name, start, finish, id, payload)
-        begin
-          instrument.increment({ controller: payload[:controller].to_s,
-                                 format: payload[:format].to_s,
-                                 action: payload[:action] })
-        rescue; end
-      end
-    end
-
-    class ProcessActionCounterReceiver < Gremlin::NotificationObserver::CounterReceiver
-      def call(name, start, finish, id, payload)
-        begin
-          instrument.increment({ controller: payload[:controller].to_s,
-                                 format: payload[:format].to_s,
-                                 action: payload[:action],
-                                 status: payload[:status] })
-        rescue; end
-      end
-    end
-
-    class ProcessActionSummaryReceiver < Gremlin::NotificationObserver::SummaryReceiver
-      def call(name, start, finish, id, payload)
-        begin
-          instrument.observe({ controller: payload[:controller],
-                               method: payload[:method],
-                               status: payload[:status],
-                               action: payload[:action] }, 
-                              payload[@field_to_observe.to_sym])
-        rescue; end
-      end
-    end
-  end
- 
+module Gremlin 
   class Railtie < ::Rails::Railtie
     config.before_initialize do
       Gremlin.configure do |c|
@@ -50,44 +15,101 @@ module Gremlin
         end
       end
     end
+  end
+end
 
-    initializer "gremlin.base_instrumentation" do |app|
+module ActionController
+  class StatsSubscriber < ActiveSupport::Subscriber
+    attach_to :action_controller
+
+    def basic_labels
       environment      = ::Rails.env.to_s
       application_name = ::Rails.application.class.parent_name.downcase
       node             = `hostname`.strip
-      basic_labels     = { node: node, app: application_name, env: environment }
-
-      next if Gremlin.disabled?
-
-      #
-      # ActionController instrumentation
-      #
-
-      # Generic instrumentation for /(start_processing|process_action|redirect_to)\.action_controller/
-      occurance_counter = Gremlin::NotificationObserver::CounterReceiver.new("notification_count",
-                                                                             "Count of notifications handled by Gremlin.",
-                                                                             basic_labels)
-      ActiveSupport::Notifications.subscribe /(start_processing|process_action|redirect_to)\.action_controller/, occurance_counter
-
-      # Instrumentation for start_processing.action_controller
-      start_processing_occurance_counter = Gremlin::ActionController::StartProcessingCounterReceiver.new("action_controller_start_processing_count",
-                                                                                                         "Count of start_processing.action_controller notifications handled by Gremlin.",
-                                                                                                         basic_labels)
-      ActiveSupport::Notifications.subscribe "start_processing.action_controller", start_processing_occurance_counter
-
-      # Instrumentation for process_action.action_controller
-      view_summary = Gremlin::ActionController::ProcessActionSummaryReceiver.new("action_controller_process_action_view_runtime_ms",
-                                                                                 "ActionController process action view runtime in milliseconds.",
-                                                                                 basic_labels, "view_runtime")
-      db_summary   = Gremlin::ActionController::ProcessActionSummaryReceiver.new("action_controller_process_action_db_runtime_ms",
-                                                                                 "ActionController process action db runtime in milliseconds.",
-                                                                                 basic_labels, "db_runtime")
-      process_action_occurance_counter = Gremlin::ActionController::ProcessActionCounterReceiver.new("action_controller_process_action_count",
-                                                                                                     "Count of process_action.action_controller notifications handled by Gremlin.",
-                                                                                                     basic_labels)
-      ActiveSupport::Notifications.subscribe "process_action.action_controller", process_action_occurance_counter
-      ActiveSupport::Notifications.subscribe "process_action.action_controller", view_summary
-      ActiveSupport::Notifications.subscribe "process_action.action_controller", db_summary
+
+      { node: node, app: application_name, env: environment }
+    end
+
+    def notification_count
+      @notification_count ||= Gremlin.registry.register Gremlin::Instruments::Counter.new("notification_count",
+                                                                                          "Count of notifications handled by Gremlin.",
+                                                                                          basic_labels)
+    end
+
+    def action_controller_start_processing_count
+      @start_processing_count ||= Gremlin.registry.register Gremlin::Instruments::Counter.new("action_controller_start_processing_count",
+                                                                                              "Count of start_processing.action_controller notifications handled by Gremlin.",
+                                                                                              basic_labels)
+    end
+
+    def action_controller_process_action_count
+      @process_action_count ||= Gremlin.registry.register Gremlin::Instruments::Counter.new("action_controller_process_action_count",
+                                                                                            "Count of process_action.action_controller notifications handled by Gremlin.",
+                                                                                            basic_labels)
+    end
+
+    def action_controller_process_action_view_runtime_ms
+      @process_action_view_runtime ||= Gremlin.registry.register Gremlin::Instruments::Summary.new("action_controller_process_action_view_runtime_ms",
+                                                                                                   "ActionController process action view runtime in milliseconds.",
+                                                                                                   basic_labels)
+    end
+
+    def action_controller_process_action_db_runtime_ms
+      @process_action_db_runtime ||= Gremlin.registry.register Gremlin::Instruments::Summary.new("action_controller_process_action_db_runtime_ms",
+                                                                                                 "ActionController process action db runtime in milliseconds.",
+                                                                                                 basic_labels)
+    end
+
+    def action_controller_process_action_total_runtime_ms
+      @process_action_total_runtime ||= Gremlin.registry.register Gremlin::Instruments::Summary.new("action_controller_process_action_total_runtime_ms",
+                                                                                                    "ActionController process action total runtime in milliseconds.",
+                                                                                                    basic_labels)
+    end
+
+    def process_action(event)
+      return if Gremlin.disabled?
+      notification_count.increment
+
+      action_controller_process_action_count.increment({ controller: event.payload[:controller].to_s,
+                                                         format: event.payload[:format].to_s,
+                                                         action: event.payload[:action],
+                                                         status: event.payload[:status] })
+
+      begin
+      action_controller_process_action_view_runtime_ms.observe({ controller: event.payload[:controller],
+                                                                 method: event.payload[:method],
+                                                                 status: event.payload[:status],
+                                                                 action: event.payload[:action] },
+                                                               event.payload[:view_runtime]
+                                                              )
+      rescue; end
+
+      begin
+      action_controller_process_action_db_runtime_ms.observe({ controller: event.payload[:controller],
+                                                                 method: event.payload[:method],
+                                                                 status: event.payload[:status],
+                                                                 action: event.payload[:action] },
+                                                              event.payload[:db_runtime]
+                                                            )
+      rescue; end
+
+      begin
+      action_controller_process_action_total_runtime_ms.observe({ controller: event.payload[:controller],
+                                                                 method: event.payload[:method],
+                                                                 status: event.payload[:status],
+                                                                 action: event.payload[:action] },
+                                                                event.duration
+                                                               )
+      rescue; end
+    end
+
+    def start_processing(event)
+      return if Gremlin.disabled?
+      notification_count.increment
+
+      action_controller_start_processing_count.increment({ controller: event.payload[:controller].to_s,
+                                                           format: event.payload[:format].to_s,
+                                                           action: event.payload[:action] })
     end
   end
 end

data/lib/gremlin/registry.rb

@@ -5,13 +5,7 @@ module Gremlin
     NotAMetricError = Class.new StandardError
 
     def initialize
-      Redis::NativeHash.redis = Redis.new(**Gremlin.configuration.redis)
-      @metrics = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new()
-      #@metrics.redis = Redis::NativeHash.redis
-      @metrics.key = retention_key
-      @metrics.save
-
-      @mutex = Mutex.new
+      @r = Redis.new(**Gremlin.configuration.redis)
     end
 
     def node
@@ -22,44 +16,40 @@ module Gremlin
       "gremlin_prometheus_#{node}_metrics_registry"
     end
 
+    def retention_get
+      @r.hgetall retention_key
+    end
+
     def metrics
-      @metrics.values.map do |m|
+      retention_get.values.map do |m|
         deserialize(m)
       end
     end
 
     def dump_metrics
-      @metrics
+      retention_get
     end
 
     def get(name)
-      m = @metrics[name.to_sym]
+      m = retention_get[name.to_s]
       deserialize(m) unless m.nil?
     end
 
     def exist?(name)
-      @metrics.key? name
+      @r.hexists retention_key, name.to_s
     end
 
     def register(instrument)
       name = instrument.name
-      raise AlreadyRegisteredError.new("#{name} has already been registered") if exist? name
-      @mutex.synchronize do
-        @metrics[name.to_sym] = serialize(instrument)
-        @metrics.save
-      end
+      set = @r.hset retention_key, name, serialize(instrument)
 
       instrument
     end
 
     def deregister(instrument)
       name = instrument.name
-      raise NotRegisteredError.new("#{name} has not been registered.") unless exist? name
-      @mutex.synchronize do
-        @metrics.delete(instrument.name.to_sym)
-        @metrics.save
-        metrics
-      end
+      raise NotRegisteredError.new() if @r.hdel(retention_key, name) == 0
+      metrics
     end
 
     def deserialize(metric)

data/lib/gremlin/version.rb

@@ -1,3 +1,3 @@
 module Gremlin
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: gremlin
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Kevin G. Phillips
+- Chris Constantine
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,13 +74,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: redis-native_hash
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -136,6 +151,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -144,6 +162,7 @@ files:
 - app/controllers/gremlin/metrics_controller.rb
 - benchmark.rb
 - bin/console
+- bin/rails
 - bin/setup
 - config/routes.rb
 - gremlin.gemspec
@@ -156,7 +175,7 @@ files:
 - lib/gremlin/notification_observer.rb
 - lib/gremlin/quantile.rb
 - lib/gremlin/quantile/estimator.rb
-- lib/gremlin/quantile/quantile.rb
+- lib/gremlin/quantile/percentile.rb
 - lib/gremlin/railtie.rb
 - lib/gremlin/registry.rb
 - lib/gremlin/version.rb

data/lib/gremlin/quantile/quantile.rb

@@ -1,16 +0,0 @@
-module Gremlin
-  module Quantile
-    class Quantile < ::Quantile::Quantile
-      def to_h
-        {
-          quantile: @quantile,
-          inaccuracy: @inaccuracy
-        }
-      end
-
-      def serialize
-        to_h.to_json
-      end
-    end
-  end
-end