gremlin 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f7287de278b662763ddc2ca3cca5d38c41bdd190
+  data.tar.gz: 823ee29d0d1dac97672d32d3649c502699271f0a
+SHA512:
+  metadata.gz: d40b078ddda9c56352cb260a493002bc9e13fa695cb781b5065fedd08c99a0c78205c8161c02953ce0004eaaf1f72473d3971744bc2d33faf5108623dee2b741
+  data.tar.gz: 6ba936ae95928ad71d409f3213921ced78bca12e71f189b38c8da808fe158bbd9e33930a7b67d2c1a3857afbb9f845a9d83b95b4343498502e5088ab7238a6dd

data/.gitignore

@@ -0,0 +1,2 @@
+*.sw*
+spec/examples.txt

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,142 @@
+PATH
+  remote: .
+  specs:
+    gremlin (0.0.1)
+      quantile
+      rails
+      redis (~> 3.2)
+      redis-native_hash
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (5.0.1)
+      actionpack (= 5.0.1)
+      nio4r (~> 1.2)
+      websocket-driver (~> 0.6.1)
+    actionmailer (5.0.1)
+      actionpack (= 5.0.1)
+      actionview (= 5.0.1)
+      activejob (= 5.0.1)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (5.0.1)
+      actionview (= 5.0.1)
+      activesupport (= 5.0.1)
+      rack (~> 2.0)
+      rack-test (~> 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.0.1)
+      activesupport (= 5.0.1)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    activejob (5.0.1)
+      activesupport (= 5.0.1)
+      globalid (>= 0.3.6)
+    activemodel (5.0.1)
+      activesupport (= 5.0.1)
+    activerecord (5.0.1)
+      activemodel (= 5.0.1)
+      activesupport (= 5.0.1)
+      arel (~> 7.0)
+    activesupport (5.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (7.1.4)
+    builder (3.2.3)
+    concurrent-ruby (1.0.4)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    globalid (0.3.7)
+      activesupport (>= 4.1.0)
+    i18n (0.7.0)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    mail (2.6.4)
+      mime-types (>= 1.16, < 4)
+    method_source (0.8.2)
+    mime-types (3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2016.0521)
+    mini_portile2 (2.1.0)
+    minitest (5.10.1)
+    nio4r (1.2.1)
+    nokogiri (1.7.0.1)
+      mini_portile2 (~> 2.1.0)
+    quantile (0.2.0)
+    rack (2.0.1)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails (5.0.1)
+      actioncable (= 5.0.1)
+      actionmailer (= 5.0.1)
+      actionpack (= 5.0.1)
+      actionview (= 5.0.1)
+      activejob (= 5.0.1)
+      activemodel (= 5.0.1)
+      activerecord (= 5.0.1)
+      activesupport (= 5.0.1)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 5.0.1)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.2)
+      activesupport (>= 4.2.0, < 6.0)
+      nokogiri (~> 1.6)
+    rails-html-sanitizer (1.0.3)
+      loofah (~> 2.0)
+    railties (5.0.1)
+      actionpack (= 5.0.1)
+      activesupport (= 5.0.1)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.5.0)
+    rdoc (5.0.0)
+    redis (3.3.2)
+    redis-native_hash (0.2.1)
+      redis (>= 2.0.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    sprockets (3.7.1)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.0)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (0.19.4)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    websocket-driver (0.6.4)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.11)
+  gremlin!
+  rake (~> 10.0)
+  rdoc
+  rspec (~> 3.3, >= 3.3.0)
+
+BUNDLED WITH
+   1.11.2

data/app/controllers/gremlin/metrics_controller.rb

@@ -0,0 +1,35 @@
+module Gremlin
+  class MetricsController < ::ActionController::Base
+    def index
+      render plain: marshal.join("\n")
+    end
+
+    def marshal
+      registry = Gremlin.registry
+
+      metrics = registry.metrics.map do |metric|
+        metric.repr
+      end
+
+      plaintext(metrics)
+    end
+
+    def plaintext(metric_representations)
+      lines = []
+      metric_representations.each do |repr|
+        lines << repr[:type]
+        lines << repr[:help]
+
+        # Prometheus expects metric labels to be of the format <label>="<label_value>"
+        repr[:values].each do |labels, value|
+          l = []
+          labels.each do |k,v|
+            l << "#{k}=\"#{v}\""
+          end
+          lines << "#{repr[:name].to_s}{#{l.join(',')}} #{value}"
+        end
+      end
+      lines
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+Gremlin::Engine.routes.draw do
+  scope module: 'gremlin' do
+    resources :metrics, only: :index
+  end
+end

data/gremlin.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gremlin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gremlin"
+  spec.version       = Gremlin::VERSION
+  spec.authors       = ["Kevin G. Phillips"]
+  spec.email         = ["platform@omadahealth.com"]
+
+  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.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~> 3.3', '>= 3.3.0'
+  spec.add_development_dependency 'rdoc'
+
+  spec.add_runtime_dependency 'redis-native_hash'
+  spec.add_runtime_dependency 'quantile'
+  spec.add_runtime_dependency 'rails'
+  spec.add_runtime_dependency 'redis', '~> 3.2'
+end

data/lib/gremlin.rb

@@ -0,0 +1,27 @@
+# Supporting librarires
+require "active_support/cache"
+require "active_support/notifications" if defined?(::Rails)
+require "quantile"
+require "json"
+require "redis_hash"
+
+# Gem internals
+require "gremlin/version"
+require "gremlin/registry"
+require "gremlin/instruments"
+require "gremlin/instruments/counter"
+require "gremlin/instruments/gauge"
+require "gremlin/instruments/summary"
+require "gremlin/quantile"
+
+# Rails support
+require "gremlin/engine" if defined?(::Rails::Engine)
+require "gremlin/railtie" if defined?(::Rails)
+
+module Gremlin
+  class << self
+    def registry
+      @registry ||= Gremlin::Registry.new
+    end
+  end
+end

data/lib/gremlin/engine.rb

@@ -0,0 +1,5 @@
+module Gremlin
+  class Engine < ::Rails::Engine
+    engine_name = "gremlin"
+  end
+end

data/lib/gremlin/instruments.rb

@@ -0,0 +1,82 @@
+module Gremlin
+  module Instruments
+    class Base
+      attr_accessor :name, :base_labels, :docstring
+
+      def initialize(name, docstring="placeholder help string", base_labels={})
+        @name = name
+        @docstring = docstring
+        @base_labels = base_labels
+        @mutex = Mutex.new
+
+        @values = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new
+        @values.key = retention_key
+        @values.save
+      end
+
+      def node
+        `hostname`.strip
+      end
+
+      def retention_key
+        nil
+      end
+
+      def type
+        nil
+      end
+
+      def type_string
+        "# TYPE #{@name} #{type}"
+      end
+
+      def default
+        nil
+      end
+
+      def help
+        @docstring
+      end
+
+      def help_string
+        "# 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 }
+        }
+      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
+        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

@@ -0,0 +1,28 @@
+require 'gremlin/instruments'
+
+module Gremlin
+  module Instruments
+    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]
+        end
+      end
+
+      def default
+        0
+      end
+
+      def type
+        :counter
+      end
+
+      def retention_key
+        "gremlin_prometheus_#{node}_metrics_counter_#{name}"
+      end
+    end
+  end
+end

data/lib/gremlin/instruments/gauge.rb

@@ -0,0 +1,23 @@
+require 'gremlin/instruments'
+
+module Gremlin
+  module Instruments
+    class Gauge < Base
+      def set(labels={}, value)
+        @mutex.synchronize do
+          @values[labels.to_json] = value
+          @values.save
+          @values[labels.to_json]
+        end
+      end
+
+      def type
+        :gauge
+      end
+
+      def retention_key
+        "gremlin_prometheus_#{node}_metrics_gauge_#{name}"
+      end
+    end
+  end
+end

data/lib/gremlin/instruments/summary.rb

@@ -0,0 +1,96 @@
+require 'gremlin/instruments'
+
+module Gremlin
+  module Instruments
+    class Summary < Base
+      class Value < Hash
+        def initialize(estimator)
+          @sum = estimator.sum
+          @total = estimator.observations
+
+          estimator.invariants.each do |invariant|
+            self[invariant.quantile] = estimator.query(invariant.quantile)
+          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
+      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
+        end
+      end
+
+      def get(labels={})
+        @mutex.synchronize do
+          val = @values[labels.to_json]
+          return val if val.nil?
+
+          deserialized = JSON.parse(val)
+          Value.new(unpack(deserialized))
+        end
+      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 }
+
+        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
+            end
+          end
+        end
+
+        {
+          name: @name,
+          type: type_string,
+          help: help_string,
+          values: values
+        }
+      end
+
+      def default
+        Gremlin::Quantile::Estimator.new
+      end
+
+      def type
+        :summary
+      end
+
+      def retention_key
+        "gremlin_prometheus_#{node}_summary_#{name}"
+      end
+    end
+  end
+end

data/lib/gremlin/quantile.rb

@@ -0,0 +1,7 @@
+require 'gremlin/quantile/estimator'
+require 'gremlin/quantile/quantile'
+
+module Gremlin
+  module Quantile
+  end
+end

data/lib/gremlin/quantile/estimator.rb

@@ -0,0 +1,27 @@
+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)]
+        end
+
+        @invariants = invariants
+        @buffer = buffer
+        @head = head
+        @observations = observations
+        @sum = sum
+      end
+
+      def serialize
+        JSON.dump({
+          invariants: @invariants.map { |i| i.to_h },
+          buffer: @buffer,
+          head: @head,
+          sum: @sum,
+          observations: @observations
+        })
+      end
+    end
+  end
+end

data/lib/gremlin/quantile/quantile.rb

@@ -0,0 +1,16 @@
+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

data/lib/gremlin/railtie.rb

@@ -0,0 +1,130 @@
+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
+        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] })
+      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] })
+
+        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])
+
+        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])
+      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
+        end
+
+        occurance_counter.increment({ status: payload[:status] })
+      end
+
+      ##
+      ## ActiveRecord
+      ##
+
+      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
+
+        # 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
+
+        occurance_counter.increment
+      end
+    end
+  end
+end

data/lib/gremlin/registry.rb

@@ -0,0 +1,74 @@
+module Gremlin
+  class Registry
+    AlreadyRegisteredError = Class.new StandardError
+    NotRegisteredError = Class.new StandardError
+    NotAMetricError = Class.new StandardError
+
+    def initialize
+      @metrics = Redis::NativeHash.find(retention_key) || Redis::NativeHash.new()
+      @metrics.key = retention_key
+      @metrics.save
+
+      @mutex = Mutex.new
+    end
+
+    def node
+      `hostname`.strip
+    end
+
+    def retention_key
+      "gremlin_prometheus_#{node}_metrics_registry"
+    end
+
+    def metrics
+      @metrics.values.map do |m|
+        deserialize(m)
+      end
+    end
+
+    def get(name)
+      m = @metrics[name.to_sym]
+      deserialize(m) unless m.nil?
+    end
+
+    def exist?(name)
+      @metrics.key? name
+    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
+
+      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
+    end
+
+    def deserialize(metric)
+      m = JSON.parse(metric)
+      Gremlin::Instruments.const_get(m["type"].capitalize).new(m["name"].to_sym, m["docstring"], m["base_labels"])
+    end
+
+    def serialize(metric)
+      raise NotAMetricError.new("Specified object is not an instrument and cannot be serialized") unless metric.is_a? Gremlin::Instruments::Base
+      {
+        type: metric.type,
+        name: metric.name.to_s,
+        docstring: metric.docstring,
+        base_labels: metric.base_labels
+      }.to_json
+    end
+  end
+end

data/lib/gremlin/version.rb

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

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: gremlin
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kevin G. Phillips
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-native_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: quantile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: A modular metrics harness for Omadahealth rails applications
+email:
+- platform@omadahealth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- app/controllers/gremlin/metrics_controller.rb
+- config/routes.rb
+- gremlin.gemspec
+- lib/gremlin.rb
+- lib/gremlin/engine.rb
+- lib/gremlin/instruments.rb
+- lib/gremlin/instruments/counter.rb
+- lib/gremlin/instruments/gauge.rb
+- lib/gremlin/instruments/summary.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
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Gem to sanely emit metrics from Omadahealth rails applications
+test_files: []
+has_rdoc: