gremlin 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7287de278b662763ddc2ca3cca5d38c41bdd190
-  data.tar.gz: 823ee29d0d1dac97672d32d3649c502699271f0a
+  metadata.gz: 9f3277bdf017d08b45ad5deb0313a9aa4fe713dd
+  data.tar.gz: 359c2c16c2438cd7366911abf975c3b802776b87
 SHA512:
-  metadata.gz: d40b078ddda9c56352cb260a493002bc9e13fa695cb781b5065fedd08c99a0c78205c8161c02953ce0004eaaf1f72473d3971744bc2d33faf5108623dee2b741
-  data.tar.gz: 6ba936ae95928ad71d409f3213921ced78bca12e71f189b38c8da808fe158bbd9e33930a7b67d2c1a3857afbb9f845a9d83b95b4343498502e5088ab7238a6dd
+  metadata.gz: ecc158ed3ff1540d04d163e4ffc5dd2d5d1a02b5cb396133e221d3d41ef521e918612c55a7db11bce2095a72b2d001e6cf820ab03898ab6d5cd1539e9b31e3e4
+  data.tar.gz: a3477c8661b90c1a227f5870dcccddc0f75b4a171ea372fe766fa552abd1324536621f1d4dd4dcadacce6afe0839d32cf702e1f11fc9de764d7d9f77da14a5b7

data/.gitignore

@@ -1,2 +1,4 @@
 *.sw*
 spec/examples.txt
+*.gem
+*.rdb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gremlin (0.0.1)
+    gremlin (0.0.2)
       quantile
       rails
       redis (~> 3.2)
@@ -54,7 +54,7 @@ GEM
     erubis (2.7.0)
     globalid (0.3.7)
       activesupport (>= 4.1.0)
-    i18n (0.7.0)
+    i18n (0.8.1)
     loofah (2.0.3)
       nokogiri (>= 1.5.9)
     mail (2.6.4)
@@ -97,7 +97,7 @@ GEM
       thor (>= 0.18.1, < 2.0)
     rake (10.5.0)
     rdoc (5.0.0)
-    redis (3.3.2)
+    redis (3.3.3)
     redis-native_hash (0.2.1)
       redis (>= 2.0.0)
     rspec (3.5.0)
@@ -121,10 +121,10 @@ GEM
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
     thor (0.19.4)
-    thread_safe (0.3.5)
+    thread_safe (0.3.6)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
-    websocket-driver (0.6.4)
+    websocket-driver (0.6.5)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.2)
 
@@ -139,4 +139,4 @@ DEPENDENCIES
   rspec (~> 3.3, >= 3.3.0)
 
 BUNDLED WITH
-   1.11.2
+   1.12.4

data/benchmark.rb

@@ -0,0 +1,143 @@
+require 'benchmark'
+require 'gremlin'
+
+
+include Benchmark
+
+print "Starting benchmarks..."
+
+orig_std_out = STDOUT.clone
+STDOUT.reopen(File::open('/dev/null', 'w'))
+
+counter_init_benchmarks = (1..100).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|
+    Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
+        counter_name = "test_#{SecureRandom.hex(5)}_counter".to_sym
+        x.report("Counter initialize then fetch") do
+            Gremlin::Instruments::Counter.new counter_name, "placeholder", {}
+            Gremlin.registry.get counter_name
+        end
+    end
+end
+
+counter_init_and_incr_benchmarks = (1..100).map do |n|
+    Benchmark.benchmark(CAPTION, 35, FORMAT) do |x|
+        counter_name = "test_#{SecureRandom.hex(5)}_counter".to_sym
+        x.report("Counter increment") do
+            counter = Gremlin::Instruments::Counter.new counter_name, "placeholder", {}
+            counter.increment
+        end
+    end
+end
+
+gauge_init_benchmarks = (1..100).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)
+        x.report("Gauge initialize") { Gremlin::Instruments::Gauge.new gauge_name, "placeholder", {} }
+    end
+end
+
+gauge_init_and_fetch_benchmarks = (1..100).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)
+        x.report("Gauge fetch") do
+            Gremlin::Instruments::Gauge.new gauge_name, "placeholder", {}
+            Gremlin.registry.get gauge_name
+        end
+    end
+end
+
+gauge_init_and_set_benchmarks = (1..100).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)
+        x.report("Gauge set") do
+            gauge = Gremlin::Instruments::Gauge.new gauge_name, "placeholder", {}
+            gauge.set({ :foo => "baz" }, gauge_set_val)
+        end
+    end
+end
+
+summary_init_benchmarks = (1..100).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 initialize") { Gremlin::Instruments::Summary.new summary_name.to_sym, "placeholder", {} }
+    end
+end
+
+summary_init_and_fetch_benchmarks = (1..100).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 fetch") do
+            Gremlin::Instruments::Summary.new summary_name.to_sym, "placeholder", {}
+            Gremlin.registry.get summary_name
+        end
+    end
+end
+
+summary_init_and_observe_benchmarks = (1..100).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)
+        end
+    end
+end
+
+STDOUT.reopen(orig_std_out)
+print "Done!\n"
+
+counter_init_agg           = counter_init_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+counter_init_and_incr_agg  = counter_init_and_incr_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+counter_init_and_fetch_agg = counter_init_and_fetch_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+
+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 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 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 ""
+
+gauge_init_agg           = gauge_init_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+gauge_init_and_fetch_agg = gauge_init_and_fetch_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+gauge_init_and_set_agg   = gauge_init_and_set_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+
+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 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 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 ""
+puts "--------------------------------------------------------"
+
+summary_init_agg               = summary_init_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+summary_init_and_fetch_agg     = summary_init_and_fetch_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+summary_init_and_observe_agg   = summary_init_and_observe_benchmarks.flatten.inject(0) { |sum, x| sum + x.real }
+
+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 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 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 ""
+puts "--------------------------------------------------------"

data/gremlin.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Gem to sanely emit metrics from Omadahealth rails applications}
   spec.description   = %q{A modular metrics harness for Omadahealth rails applications}
-  spec.homepage      = "https://github.com/omadahealth/omada-metrics"
+  spec.homepage      = "https://github.com/omadahealth/gremlin"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or

data/lib/gremlin.rb

@@ -1,9 +1,11 @@
 # Supporting librarires
 require "active_support/cache"
 require "active_support/notifications" if defined?(::Rails)
-require "quantile"
+require "erb"
 require "json"
+require "quantile"
 require "redis_hash"
+require "yaml"
 
 # Gem internals
 require "gremlin/version"
@@ -13,6 +15,7 @@ require "gremlin/instruments/counter"
 require "gremlin/instruments/gauge"
 require "gremlin/instruments/summary"
 require "gremlin/quantile"
+require "gremlin/notification_observer"
 
 # Rails support
 require "gremlin/engine" if defined?(::Rails::Engine)
@@ -20,8 +23,37 @@ require "gremlin/railtie" if defined?(::Rails)
 
 module Gremlin
   class << self
+    attr_reader :configuration
+
     def registry
       @registry ||= Gremlin::Registry.new
     end
+
+    def configuration
+      unless @configuration
+        @configuration = configure do |c|
+          c.redis = { :host => "localhost", :port => 6379, :db => 15 }
+          c.enabled = true
+        end
+      end
+      @configuration
+    end
+
+    def configure
+      config = Config.new
+      yield config
+      @configuration = config
+    end
+
+    def enabled?
+      @configuration.enabled
+    end
+
+    def disabled?
+      not enabled?
+    end
+  end
+
+  class Config < Struct.new(:redis, :enabled)
   end
 end

data/lib/gremlin/instruments.rb

@@ -9,7 +9,10 @@ module Gremlin
         @base_labels = base_labels
         @mutex = Mutex.new
 
+        Redis::Client.default = Redis.new(**Gremlin.configuration.redis)
+        @r = Redis.new(**Gremlin.configuration.redis)
         @values = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new
+        @values.redis = Redis.new(**Gremlin.configuration.redis)
         @values.key = retention_key
         @values.save
       end
@@ -65,18 +68,6 @@ module Gremlin
           end
         end
       end
-
-      def get(labels={})
-        v = @values[labels.to_json]
-        case type
-        when :counter
-          v.to_i
-        when :gauge
-          v.to_f
-        else
-          v
-        end
-      end
     end
   end
 end

data/lib/gremlin/instruments/counter.rb

@@ -5,10 +5,7 @@ module Gremlin
     class Counter < Base
       def increment(labels={}, by=1)
         @mutex.synchronize do
-          prev_val = get(labels.to_json) || default
-          @values[labels.to_json] = prev_val + by
-          @values.save
-          @values[labels.to_json]
+          @r.hincrby retention_key, labels.to_json, by
         end
       end
 
@@ -23,6 +20,12 @@ module Gremlin
       def retention_key
         "gremlin_prometheus_#{node}_metrics_counter_#{name}"
       end
+
+      def get(labels={})
+        @values.reload!
+        v = @values[labels.to_json]
+        v.to_i
+      end
     end
   end
 end

data/lib/gremlin/instruments/gauge.rb

@@ -5,9 +5,8 @@ module Gremlin
     class Gauge < Base
       def set(labels={}, value)
         @mutex.synchronize do
-          @values[labels.to_json] = value
-          @values.save
-          @values[labels.to_json]
+          @r.hset retention_key, labels.to_json, value
+          get(labels)
         end
       end
 
@@ -18,6 +17,12 @@ module Gremlin
       def retention_key
         "gremlin_prometheus_#{node}_metrics_gauge_#{name}"
       end
+
+      def get(labels={})
+        @values.reload!
+        v = @values[labels.to_json]
+        v.to_f
+      end
     end
   end
 end

data/lib/gremlin/notification_observer.rb

@@ -0,0 +1,38 @@
+module Gremlin
+  module NotificationObserver
+    class CounterReceiver
+      def initialize(name, docstring, labels)
+        @instrument = Gremlin::Instruments::Counter.new(name, docstring, labels)
+        begin
+          Gremlin.registry.register @instrument
+        rescue Gremlin::Registry::AlreadyRegisteredError; end
+      end
+
+      def call(name, start, finish, id, payload)
+        instrument.increment({})
+      end
+
+      def instrument
+        Gremlin.registry.get(@instrument.name)
+      end
+    end
+
+    class SummaryReceiver
+      def initialize(name, docstring, labels, payload_field)
+        @instrument = Gremlin::Instruments::Summary.new(name, docstring, labels)
+        begin
+          Gremlin.registry.register @instrument
+        rescue Gremlin::Registry::AlreadyRegisteredError; end
+        @field_to_observe = payload_field
+      end
+
+      def call(name, start, finish, id, payload)
+        instrument.observe({}, payload[@field_to_observe.to_sym])
+      end
+
+      def instrument
+        Gremlin.registry.get(@instrument.name)
+      end
+    end
+  end
+end

data/lib/gremlin/railtie.rb

@@ -1,130 +1,93 @@
 module Gremlin
-  class Railtie < ::Rails::Railtie
-    config.before_initialize do
-      # XXX is there anything to configure? redis?
-    end
-
-    initializer "gremlin.base_instrumentation" do |app|
-      environment = ::Rails.env.to_s
-      application_name = ::Rails.application.class.parent_name.downcase
-      node = `hostname`.strip
-
-      #
-      # ActionController
-      #
-
-      ActiveSupport::Notifications.subscribe "start_processing.action_controller" do |name, start, finish, id, payload|
-        # Payload contains:
-        # :controller      ---    The controller name
-        # :action          ---    The action
-        # :params          ---    Hash of request parameters without any filtered parameter
-        # :headers         ---    Request headers
-        # :format          ---    html/js/json/xml etc
-        # :method          ---    HTTP request verb
-        # :path            ---    Request path
-
-        # Counter to track event occurances
+   module ActionController
+    class StartProcessingCounterReceiver < Gremlin::NotificationObserver::CounterReceiver
+      def call(name, start, finish, id, payload)
         begin
-          occurance_counter = Gremlin::Instruments::Counter.new("action_controller_start_processing_events".to_sym,
-                                                              "ActionController start processing occurance counter.",
-                                                              application: application_name, environment: environment, node: node)
-          Gremlin.registry.register occurance_counter
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          occurance_counter = Gremlin.registry.get "action_controller_start_processing_events".to_sym
-        end
-
-        occurance_counter.increment({ controller: payload[:controller].to_s, format: payload[:format].to_s, action: payload[:action] })
+          instrument.increment({ controller: payload[:controller].to_s,
+                                 format: payload[:format].to_s,
+                                 action: payload[:action] })
+        rescue; end
       end
+    end
 
-      ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
-        # Payload contains:
-        # :controller      ---    The controller name
-        # :action          ---    The action
-        # :params          ---    Hash of request parameters *without any filtered parameter*
-        # :headers         ---    Request headers
-        # :format          ---    html/js/json/xml etc
-        # :method          ---    HTTP request verb
-        # :path            ---    Request path
-        # :status          ---    HTTP status code
-        # :view_runtime    ---    Amount spent in view in ms
-        # :db_runtime      ---    Amount spent executing database queries in ms
-
-        # Counter to track event occurances
-        begin
-          occurance_counter = Gremlin::Instruments::Counter.new("action_controller_process_action_events".to_sym,
-                                                              "ActionController process action occurance counter.",
-                                                              application: application_name, environment: environment, node: node)
-          Gremlin.registry.register occurance_counter
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          occurance_counter = Gremlin.registry.get "action_controller_process_action_events".to_sym
-        end
-
-        occurance_counter.increment({ controller: payload[:controller].to_s, format: payload[:format].to_s, action: payload[:action], status: payload[:status] })
-
+    class ProcessActionCounterReceiver < Gremlin::NotificationObserver::CounterReceiver
+      def call(name, start, finish, id, payload)
         begin
-          db_summary = Gremlin::Instruments::Summary.new("action_controller_process_action_db_runtime_ms".to_sym,
-                                                       "ActionController process action DB runtime in milliseconds.",
-                                                       application: application_name, environment: environment, node: node)
-          Gremlin.registry.register db_summary
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          db_summary = Gremlin.registry.get "action_controller_process_action_db_runtime_ms".to_sym
-        end
-
-        db_summary.observe({ controller: payload[:controller], method: payload[:method], status: payload[:status], action: payload[:action] }, payload[:db_runtime])
+          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
-          view_summary = Gremlin::Instruments::Summary.new("action_controller_process_action_view_runtime_ms".to_sym,
-                                                         "ActionController process action view runtime in milliseconds.",
-                                                         application: application_name, environment: environment, node: node)
-          Gremlin.registry.register view_summary
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          view_summary = Gremlin.registry.get "action_controller_process_action_view_runtime_ms".to_sym
-        end
-
-        view_summary.observe({ controller: payload[:controller], method: payload[:method], status: payload[:status], action: payload[:action] }, payload[:view_runtime])
+          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
+ 
+  class Railtie < ::Rails::Railtie
+    config.before_initialize do
+      Gremlin.configure do |c|
+        c.redis = { url: "localhost", port: 6379, db: 15 }
+        c.enabled = true
       end
 
-      ActiveSupport::Notifications.subscribe "redirect_to.action_controller" do |name, start, finish, id, payload|
-        # Payload contains:
-        # :status          ---    HTTP response code
-        # :location        ---    URL to redirect to
-
-        # Counter to track event occurances
-        begin
-          occurance_counter = Gremlin::Instruments::Counter.new("action_controller_redirect_to_events".to_sym,
-                                                              "ActionController redirect to occurance counter.",
-                                                              application: application_name, environment: environment, node: node)
-          Gremlin.registry.register occurance_counter
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          occurance_counter = Gremlin.registry.get "action_controller_redirect_to_events".to_sym
+      conf_file = ::Rails.root.join("config", "gremlin.yml")
+      config    = YAML.load(ERB.new(File.read(conf_file)).result) if File.exists?(conf_file)
+      if config
+        Gremlin.configure do |c|
+          c.redis = config[::Rails.env] ? config[::Rails.env]["redis"] : config["redis"]
+          c.enabled = config[::Rails.env] ? config[::Rails.env]["enabled"] : config["enabled"]
         end
-
-        occurance_counter.increment({ status: payload[:status] })
       end
+    end
 
-      ##
-      ## ActiveRecord
-      ##
+    initializer "gremlin.base_instrumentation" do |app|
+      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 }
 
-      ActiveSupport::Notifications.subscribe "sql.active_record" do |name, start, finish, id, payload|
-        # Payload contains:
-        # :sql             ---    SQL statement
-        # :name            ---    Name of the operation
-        # :connection_id   ---    self.object_id
-        # :binds           ---    Bind parameters
+      next if Gremlin.disabled?
 
-        # Counter to track event occurances
-        begin
-          occurance_counter = Gremlin::Instruments::Counter.new("active_record_sql_events".to_sym,
-                                                              "ActiveRecord SQL occurance counter.",
-                                                              application: application_name, environment: environment, node: node)
-          Gremlin.registry.register occurance_counter
-        rescue Gremlin::Registry::AlreadyRegisteredError
-          occurance_counter = Gremlin.registry.get "active_record_sql_events".to_sym
-        end
+      #
+      # ActionController instrumentation
+      #
 
-        occurance_counter.increment
-      end
+      # 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
     end
   end
 end

data/lib/gremlin/registry.rb

@@ -5,7 +5,9 @@ module Gremlin
     NotAMetricError = Class.new StandardError
 
     def initialize
+      Redis::Client.default = Redis.new(**Gremlin.configuration.redis)
       @metrics = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new()
+      @metrics.redis = Redis.new(**Gremlin.configuration.redis)
       @metrics.key = retention_key
       @metrics.save
 
@@ -26,6 +28,10 @@ module Gremlin
       end
     end
 
+    def dump_metrics
+      @metrics
+    end
+
     def get(name)
       m = @metrics[name.to_sym]
       deserialize(m) unless m.nil?

data/lib/gremlin/version.rb

@@ -1,3 +1,3 @@
 module Gremlin
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gremlin
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kevin G. Phillips
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-17 00:00:00.000000000 Z
+date: 2017-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,6 +139,7 @@ files:
 - Gemfile
 - Gemfile.lock
 - app/controllers/gremlin/metrics_controller.rb
+- benchmark.rb
 - config/routes.rb
 - gremlin.gemspec
 - lib/gremlin.rb
@@ -147,13 +148,14 @@ files:
 - lib/gremlin/instruments/counter.rb
 - lib/gremlin/instruments/gauge.rb
 - lib/gremlin/instruments/summary.rb
+- lib/gremlin/notification_observer.rb
 - lib/gremlin/quantile.rb
 - lib/gremlin/quantile/estimator.rb
 - lib/gremlin/quantile/quantile.rb
 - lib/gremlin/railtie.rb
 - lib/gremlin/registry.rb
 - lib/gremlin/version.rb
-homepage: https://github.com/omadahealth/omada-metrics
+homepage: https://github.com/omadahealth/gremlin
 licenses:
 - MIT
 metadata: