g5_prom_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b989ca4a0078f71ac841968d0856eee42d502b3
+  data.tar.gz: f3b202a9f269331b49a22451115929e456ba5dff
+SHA512:
+  metadata.gz: 45635669ba0ee1ec30a31c16103e2bd8363ea088405cb8e91e4811c6ee14d717c148324412d76c2bcdb947da9c9f8745966bd277b83eccfe462b890cfe8f91f8
+  data.tar.gz: 8f07da93804aa4cb94cde9f4317e041e9a70ef435135c2a753211c44e705c9f4433afc8aec88c58405262810f29a33bf50272998252379516cbe9000388cbcd1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Don Petersen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# G5 Prom Rails
+
+This gem provides a rails engine that provides very basic help in integrating Prometheus into your Rails app. It brings in Prometheus Exporter middleware, initializes a metrics registry, and can add metrics for common use-cases and Rails gems.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'g5_prom_rails'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Usage
+
+The engine brings in the `prometheus-client` ruby gem. It is well-documented, and `g5_prom_rails` doesn't insulate you from how that gem works. You should [read its documentation](https://github.com/prometheus/client_ruby) to understand what metric types are available to you and how to update them. Registries and metrics endpoints are configured for you.
+
+This gem is designed to work when Prometheus scrapes both individual instances of Rails (horizontally scaled processes) and the application as a whole. Application-level metrics are those that are shared between every Rails process, like database model counts or background job queue sizes. Per-process metrics are instrumented events that hit individual processes, like a particular controller action being called. Prometheus deals with aggregating events that happen in multiple disconnected processes, like load balanced Rails web servers.
+
+## Configuration
+
+There are a few configuration points for the engine, which you should specify in an initializer. Here's an example of a simple recommended setup:
+
+**`config/initializers/metrics.rb`**
+```ruby
+METRICS = Metrics.new
+
+G5PromRails.initialize_per_application = -> (registry) {
+  METRICS.initialize_per_application(registry)
+}
+
+G5PromRails.initialize_per_application = -> (registry) {
+  METRICS.initialize_per_process(registry)
+}
+
+G5PromRails.add_refresh_hook do
+  METRICS.published_posts.set({}, Post.where(published: true).count)
+end
+```
+
+**`lib/metrics.rb`**
+```ruby
+class Metrics
+  attr_reader :published_posts, :post_shares
+
+  def initialize_per_application(registry)
+    @published_posts = registry.gauge(:my_app_posts, "published blog posts")
+  end
+
+  def initialize_per_application(registry)
+    @post_shares = registry.counter(:my_app_post_shares, "blog post shares")
+  end
+end
+```
+
+**`app/controllers/posts_controller.rb`**
+```ruby
+class PostsController < ApplicationController
+  def share
+    METRICS.post_shares.increment
+    # ... a bunch of important business logic
+  end
+end
+```
+
+There are a few things going on here. In the initializer, you have hooks to initialize new metric types depending on their scope. Each lambda is passed a Prometheus registry instance, which is where you attach the metric types. They are safe for concurrent access, and the individual metric instances you're instantiating are the objects you'll be interacting with in your code when you want to instrument something.
+
+The `Metrics` class is part of your codebase, and this structure is only a recommendation. I'm suggesting that fewer global variables are easier to deal with, but you could reimplement what I've done here with multiple globals and keep it all within your initializer (except the controller instrumentation).
+
+We're instrumenting two things in this example: the number of Posts in the database, and the number of times any Post was shared.
+
+Post count hits the database, and no matter which process you asked, the answer would be the same. You do *not* want to ask every process individually as it would generate pointless database queries and multiple copies of the same data.
+
+Share count is per-process. With a load balancer and scaled web processes, different instances of your application might serve the request to share a blog post. You increment a counter in your controller code, and Prometheus deals with aggregating the differing values for this metric from each process.
+
+An additional wrinkle is the `add_refresh_hook` in the initializer. This is a hook to update your metrics when the application-level metrics endpoint is hit. For a metric like database row counts, this is the easiest place to make sure the metrics up-to-date before you provide them to Prometheus. Because this hook is called every time the endpoint is hit, you should avoid any extremely strenuous queries, as it will be called at Prometheus's regular scrape interval.
+
+## Warnings
+
+There are a couple of general Prometheus tips things to keep in mind.
+
+  * Namespace your metrics. If you named a metric `users`, that's the name of the metric for every other user of your Prometheus server. You should name it `your_app_users`. This engine does not force namespaces on you, because it's possible you'll want to aggregate metrics across multiple applications.
+  * Read [the official Prometheus guidelines on metric naming](https://prometheus.io/docs/practices/naming/). It's short and extremely helpful.
+  * Did you see the big warning at the end of the naming guidelines? Labels in Prometheus are extremely powerful; I encourage you to use them, but don't abuse them. A new time series database is created for every combination of label values. Feel free to use a label that could have dozens of possible values, for instance in your blog post counter to differentiate drafts from published articles. Do *not* use `author_id` as a label to count posts by author. *Especially* do not use multiple labels that could have many possible values, because the effect on the total number of time series databases is multiplicative.
+
+## App Name
+
+As you will soon learn, G5PromRails can provide you with some automatic metrics. Most of them are scoped to your application's name. It will attempt to infer the application's name from the Rails Application class's (`config/application.rb`) dasherized parent module name. If that doesn't work for you, it can be manually defined with:
+
+```ruby
+G5PromRails.app_name = "my_app_name"
+```
+
+## Sidekiq
+
+Prometheus's strategy is to scrape metrics. If you take a moment to think about it, we have a problem: how do you scrape in-memory metrics from a Sidekiq worker? That process doesn't start a web server.
+
+Well, it does now. If you have Sidekiq and the process is a worker, it will start a thread with a simple Rack server that only serves metric. By default this will run on port 3000, but it can be configured with:
+
+```ruby
+G5PromRails.sidekiq_scrape_server_port = 3001
+```
+
+If your application includes Sidekiq, G5PromRails will detect it and include several metrics using Sidekiq's built-in statistics classes. It also adds a benchmarking middleware to the Sidekiq server middleware chain.
+
+Metrics include:
+
+  * *`sidekiq_processed`* Counter for jobs processed.
+  * *`sidekiq_failed`* Counter for jobs failed.
+  * *`sidekiq_retry`* Gauge for current retries length.
+  * *`sidekiq_queued`* Gauge for current queue length. The label `queue` is applied to allow per-queue analysis.
+  * *`sidekiq_job_seconds`*,*`sidekiq_job_seconds_sum`*,*`sidekiq_job_seconds_count`* Histogram for job execution time. The label `job_name` is applied, and will be identical to the Ruby class name of the job (e.g. `MyImportantWorker`). To understand how to use this data, look at [the official documentation](https://prometheus.io/docs/practices/histograms/). See particularly the section about aggregation.
+
+Each metric also has the `app` label applied with the name of your application.
+
+## Helpers
+
+There are some common instrumentation tasks that this gem can help you with.
+
+#### Row Counts
+
+When you'd like to instrument the count of certain ActiveRecord models, in an initializer you can:
+
+```ruby
+G5PromRails.count_models(:my_app, Post, Comment)
+```
+
+Will result in a gauge metric named `model_rows` with a `model` label set to the tableized name of your model and an `app` label set to the `my_app`. In PromQL this will look like:
+```promql
+model_rows{model="posts", app="my_app"}
+```
+
+This metric is left un-namespaced because it gives you the ability to compare these values across applications, while still allowing them to be limited to a single app via PromQL. The values will automatically be refreshed when the application-level metrics endpoint is hit.
+
+## Development
+
+To run this engine's tests, you need redis running. Sorry. You need to do some finagling to get Sidekiq using fakeredis, and I didn't feel like spending the time on it. I'm using Sidekiq::Stats, which isn't part of any of sidekiq's normal testing setup.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'G5PromRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/config/g5_prom_rails_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/g5_prom_rails .js
+//= link_directory ../stylesheets/g5_prom_rails .css

data/app/assets/javascripts/g5_prom_rails/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/g5_prom_rails/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/g5_prom_rails/application_controller.rb

@@ -0,0 +1,5 @@
+module G5PromRails
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/helpers/g5_prom_rails/application_helper.rb

@@ -0,0 +1,4 @@
+module G5PromRails
+  module ApplicationHelper
+  end
+end

data/app/jobs/g5_prom_rails/application_job.rb

@@ -0,0 +1,4 @@
+module G5PromRails
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/g5_prom_rails/application_mailer.rb

@@ -0,0 +1,6 @@
+module G5PromRails
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/g5_prom_rails/application_record.rb

@@ -0,0 +1,5 @@
+module G5PromRails
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/g5_prom_rails/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>G5 prom rails</title>
+  <%= stylesheet_link_tag    "g5_prom_rails/application", media: "all" %>
+  <%= javascript_include_tag "g5_prom_rails/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+G5PromRails::Engine.routes.draw do
+end

data/lib/g5_prom_rails.rb

@@ -0,0 +1,26 @@
+require "g5_prom_rails/engine"
+
+module G5PromRails
+  PER_PROCESS_PATH = "/metrics"
+  PER_APPLICATION_PATH = "/probe"
+
+  cattr_accessor :app_name
+  cattr_accessor :initialize_per_application, :initialize_per_process
+  cattr_accessor :sidekiq_scrape_server_port
+
+  def self.add_refresh_hook(&block)
+    @@refresh_hooks ||= []
+    @@refresh_hooks << block
+  end
+
+  def self.refresh_gauges
+    return if @@refresh_hooks.nil?
+    @@refresh_hooks.each { |b| b.call }
+  end
+
+  def self.count_models(*models)
+    add_refresh_hook do
+      Metrics.update_model_count_gauge(*models)
+    end
+  end
+end

data/lib/g5_prom_rails/engine.rb

@@ -0,0 +1,90 @@
+require 'prometheus/client/rack/exporter'
+require_relative 'metrics'
+require_relative 'refreshing_exporter'
+require_relative 'settable_counter'
+require_relative 'sidekiq_timing_middleware'
+
+module G5PromRails
+  class Engine < ::Rails::Engine
+    isolate_namespace G5PromRails
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer "g5_prom_rails.configure_global" do |app|
+      app_name = G5PromRails.app_name || app.class.parent_name.underscore.dasherize
+      G5PromRails::Metrics = MetricsContainer.new(app_name)
+
+      if G5PromRails.initialize_per_application.present?
+        G5PromRails::Metrics.per_application.instance_eval(
+          &G5PromRails.initialize_per_application
+        )
+      end
+
+      if G5PromRails.initialize_per_process.present?
+        G5PromRails::Metrics.per_process.instance_eval(
+          &G5PromRails.initialize_per_process
+        )
+      end
+    end
+
+    initializer "g5_prom_rails.add_exporter" do |app|
+      Prometheus::Client::Rack::Exporter.send(
+        :prepend,
+        G5PromRails::RefreshingExporter
+      )
+
+      per_application_opts = {
+        path: G5PromRails::PER_APPLICATION_PATH,
+        registry: G5PromRails::Metrics.per_application
+      }
+      per_process_opts = {
+        path: G5PromRails::PER_PROCESS_PATH,
+        registry: G5PromRails::Metrics.per_process
+      }
+
+      # has sidekiq and is a worker
+      if defined?(Sidekiq) && Sidekiq.server?.present?
+        app = Rack::Builder.new do
+          use Rack::ShowExceptions
+          use Rack::Lint
+          use Prometheus::Client::Rack::Exporter, per_process_opts
+          run -> { [ '404', {}, ["Not Found"] ] }
+        end
+
+        Thread.new do
+          Rails.logger.info("started g5_prom_rails metrics endpoint...")
+          Rack::Server.start(
+            app: app,
+            Port: (G5PromRails.sidekiq_scrape_server_port || 3000),
+          )
+        end
+      else
+        app.middleware.use(Prometheus::Client::Rack::Exporter, per_process_opts)
+        app.middleware.use(Prometheus::Client::Rack::Exporter, per_application_opts)
+      end
+    end
+
+    initializer "g5_prom_rails.maybe_configure_sidekiq" do |app|
+      if defined?(Sidekiq)
+        G5PromRails.add_refresh_hook do
+          Metrics.update_sidekiq_statistics
+        end
+
+        timing_metric = G5PromRails::SidekiqTimingMiddleware.build_metric(
+          G5PromRails::Metrics.per_process
+        )
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add(
+              G5PromRails::SidekiqTimingMiddleware,
+              app: G5PromRails::Metrics.app,
+              metric: timing_metric
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/g5_prom_rails/metrics.rb

@@ -0,0 +1,35 @@
+require_relative 'sidekiq_application_metrics'
+
+class G5PromRails::MetricsContainer
+  if defined?(Sidekiq)
+    include G5PromRails::SidekiqApplicationMetrics
+  end
+
+  MODEL_COUNT_NAME = :model_rows
+
+  attr_reader :app
+  attr_reader :per_process, :per_application
+
+  def initialize(app)
+    @app = app
+    @per_process = Prometheus::Client::Registry.new
+    @per_application = Prometheus::Client::Registry.new
+    @model_count_gauge = @per_application.gauge(MODEL_COUNT_NAME, "model row counts")
+    try(:initialize_sidekiq_application)
+  end
+
+  def update_model_count_gauge(*models)
+    models.each do |model|
+      @model_count_gauge.set(
+        { app: app, model: model.name.tableize },
+        model.count
+      )
+    end
+  end
+
+protected
+
+  def app_hash(h = {})
+    { app: app }.merge(h)
+  end
+end

data/lib/g5_prom_rails/refreshing_exporter.rb

@@ -0,0 +1,6 @@
+module G5PromRails::RefreshingExporter
+  def respond_with(format)
+    G5PromRails.refresh_gauges if @path == G5PromRails::PER_APPLICATION_PATH
+    super
+  end
+end

data/lib/g5_prom_rails/settable_counter.rb

@@ -0,0 +1,15 @@
+# prometheus-client provides a counter that can only be incremented. That works
+# great for instrumenting events, but in the case of something like Sidekiq
+# Processed count, prometheus (the server) can handle resets and all kinds of
+# great stuff if I simply pass the count as-is. Rather than having to monkey
+# with saving the previous value and all that nonsense, I just want to set the
+# value and let the server deal with it.
+class G5PromRails::SettableCounter < Prometheus::Client::Metric
+  def type
+    :counter
+  end
+
+  def set(labels, value)
+    @values[label_set_for(labels)] = value
+  end
+end

data/lib/g5_prom_rails/sidekiq_application_metrics.rb

@@ -0,0 +1,38 @@
+require 'sidekiq/api'
+
+module G5PromRails::SidekiqApplicationMetrics
+  extend ActiveSupport::Concern
+
+  def initialize_sidekiq_application
+    @processed_counter = G5PromRails::SettableCounter.new(
+      :sidekiq_processed,
+      "jobs processed"
+    )
+    per_application.register(@processed_counter)
+    @failed_counter = G5PromRails::SettableCounter.new(
+      :sidekiq_failed,
+      "jobs failed"
+    )
+    per_application.register(@failed_counter)
+
+    @retry_gauge = per_application.gauge(
+      :sidekiq_retry,
+      "jobs to be retried"
+    )
+    @queues_gauge = per_application.gauge(
+      :sidekiq_queued,
+      "job queue lengths"
+    )
+  end
+
+  def update_sidekiq_statistics
+    stats = Sidekiq::Stats.new
+    @processed_counter.set(app_hash, stats.processed)
+    @failed_counter.set(app_hash, stats.failed)
+    @retry_gauge.set(app_hash, stats.retry_size)
+
+    Sidekiq::Stats::Queues.new.lengths.each do |queue, length|
+      @queues_gauge.set(app_hash(queue: queue), length)
+    end
+  end
+end

data/lib/g5_prom_rails/sidekiq_timing_middleware.rb

@@ -0,0 +1,37 @@
+class G5PromRails::SidekiqTimingMiddleware
+  def self.build_metric(reg)
+    reg.histogram(
+      :sidekiq_job_seconds,
+      "job running time in seconds",
+      {},
+      [
+        10,
+        30,
+        90,
+        3.minutes.to_i,
+        7.minutes.to_i,
+        12.minutes.to_i,
+        20.minutes.to_i,
+        35.minutes.to_i,
+        60.minutes.to_i,
+        80.minutes.to_i,
+        2.hours.to_i,
+        3.hours.to_i,
+        5.hours.to_i,
+        10.hours.to_i,
+      ]
+    )
+  end
+
+  def initialize(options = nil)
+    @app = options[:app]
+    @metric = options[:metric]
+  end
+
+  def call(worker, msg, queue)
+    @metric.observe(
+      { app: @app, job_class: worker.class.name },
+      Benchmark.realtime { yield }
+    )
+  end
+end

data/lib/g5_prom_rails/version.rb

@@ -0,0 +1,3 @@
+module G5PromRails
+  VERSION = '0.1.0'
+end

data/lib/tasks/g5_prom_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :g5_prom_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: g5_prom_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Don Petersen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: prometheus-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !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:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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: sidekiq
+  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'
+description: Rails-friendly prometheus base
+email:
+- don@donpetersen.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/g5_prom_rails_manifest.js
+- app/assets/javascripts/g5_prom_rails/application.js
+- app/assets/stylesheets/g5_prom_rails/application.css
+- app/controllers/g5_prom_rails/application_controller.rb
+- app/helpers/g5_prom_rails/application_helper.rb
+- app/jobs/g5_prom_rails/application_job.rb
+- app/mailers/g5_prom_rails/application_mailer.rb
+- app/models/g5_prom_rails/application_record.rb
+- app/views/layouts/g5_prom_rails/application.html.erb
+- config/routes.rb
+- lib/g5_prom_rails.rb
+- lib/g5_prom_rails/engine.rb
+- lib/g5_prom_rails/metrics.rb
+- lib/g5_prom_rails/refreshing_exporter.rb
+- lib/g5_prom_rails/settable_counter.rb
+- lib/g5_prom_rails/sidekiq_application_metrics.rb
+- lib/g5_prom_rails/sidekiq_timing_middleware.rb
+- lib/g5_prom_rails/version.rb
+- lib/tasks/g5_prom_rails_tasks.rake
+homepage: http://github.com/G5/g5_prom_rails
+licenses:
+- MIT
+metadata: {}
+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: Rails-friendly prometheus base
+test_files: []