active_monitoring 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d713464ea142fd4d40db7b8b12b786f3fd21c85d052cc9fbe2eb9fcb5ece2a87
+  data.tar.gz: 94c592b0e41fe8be9c609525eb429979cb67f382179baaae902abcd4b256b031
+SHA512:
+  metadata.gz: 56afc9fc77d56d52437671acfe644308e83f13d1a0fe91b2b38ded82b0f007156eec4784d75d6ba041c57bed97ba301a3334bb1dd88a8ce4a4e824993d01ff02
+  data.tar.gz: b1b763e859633c3255693fa5b3453cadccf6184788f5482f18913bbcc8c7cc8dc88d1429fe4a9fa50b721f646ca39a4befb36fb20fc1f76a27122803a87b63fb

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Christian Bruckmayer
+
+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,182 @@
+# ActiveMonitoring
+
+I gave this talk at [RailsConf 2020 Couch Edition](https://railsconf.com/) and this blog article contains the source code and step by step tutorial.
+The talk and tutorial is inspired by my work on [influxdb-rails](https://github.com/influxdata/influxdb-rails) and contains several patterns and learnings from it.
+
+By the end of this tutorial, we will have a very basic Performance Monitoring tool which measures the response and SQL query time of a Rails application.
+
+## Abstract
+> Building a Performance Analytics Tool with ActiveSupport
+
+> Setting up a performance analytics tool like NewRelic or Skylight is one of the first things many developers do in a new project. However, have you ever wondered how these tools work under the hood?
+
+> In this talk, we will build a basic performance analytics tool from scratch. We will deep dive into ActiveSupport instrumentations to collect, group and normalise metrics from your app. To persist these metrics, we will use a time series database and visualise the data on a dashboard. By the end of the talk, you will know how your favourite performance analytics tool works.
+
+## Chapter 1: Collecting data
+### Notification Framework
+As a first step we need to implement a notification framework which we can use to instrument and subscribe to performance metrics.
+
+A basic example of the functionality of our notification framework would be this code:
+```ruby
+scenario "It can susbcribe and instrument events" do
+  events = []
+  ActiveMonitoring::Notifications.subscribe("test_event") do |name, start, finish, id, payload|
+    events << { name: name, start: start, finish: finish, id: id, payload: payload }
+  end
+
+  ActiveMonitoring::Notifications.instrument("test_event", payload: :payload) do
+    1 + 1
+  end
+
+  expect(metrics[0].name).to eq("test_event")
+  expect(metrics[0].payload).to include(payload: :payload)
+end
+```
+
+The implementation can be found in commit [32c3](https://github.com/ChrisBr/active_monitoring/commit/32c32dcec7529ac7a8e0125b1aaab28cd4219363).
+For the sake of simplicity, this framework is not thread safe of course.
+
+This framework is inspired by [ActiveSupport Notifications](https://edgeguides.rubyonrails.org/active_support_instrumentation.html) which already provides various hooks into Rails internals.
+The implementatition of Active Support Notifications can be found [here](https://github.com/rails/rails/tree/master/activesupport/lib/active_support/notifications).
+
+### Instrument events
+[ActiveSupport Notifications](https://edgeguides.rubyonrails.org/active_support_instrumentation.html) provides already
+several hooks to subscribe to e.g. processing of controller actions, SQL queries or view rendering.
+However, Rails does not provide hooks for external libraries like Redis or Memcache.
+In [ef20](https://github.com/ChrisBr/active_monitoring/commit/ef200ae5bf58f9afd2a69003e2c3620d0d9c86eb) and [46c3](https://github.com/ChrisBr/active_monitoring/commit/46c338f8fa5870bae7dc0e251e637d1d4be551db) we monkey patch Rails
+to subscribe to controller actions and SQL queries.
+
+## Chapter 2: Storage
+In chapter two we discussed an appropriate storage engine for our data.
+Our data would look for example like this
+
+| Timestamp  | Hook | Location | Request ID | Value |
+| ------------- | ------------- |------------- |------------- |------------- |
+| 01.04.2020 00:31:30 CET | process_action | BooksController#show | cf6d6dcd | 100 ms
+| 01.04.2020 00:32:30 CET | sql | BooksController#show | c7c7c841 | 80 ms
+
+This data looks tabular, so using a relational database to store it would make sense.
+However, there are several downsides to this approach.
+
+### Relational Database
+
+Relational databases perform very well with applications which map to the basic CRUD operations of the database like a Rails controller.
+
+```ruby
+class BooksController < ApplicationController
+  def new; end
+  def create; end
+  def show; end
+  def edit; end
+  def update; end
+  def destroy; end
+end
+```
+
+However, our plugin does not really use all of these traditional database operations or in a different way we would in a normal Rails app.
+
+#### Create
+For each request, we will write one process action and several SQL query data points.
+If we extend this application to also cover view render times or background jobs, it's not unlikely we would write 10+ metrics per request.
+Depending of how many requests your app does process, we could easily create millions of metrics per year.
+
+#### Read
+We will read the metrics in a dashboard for a certain time range like today or last three hours but not randomly.
+
+#### Update
+We will almost never go back to update on of the metrics.
+
+#### Delete
+We will only delete metrics in batches but not single metrics.
+For instance, we are only interested in metrics for the last three months so once a month we can do a 'garbage collection' and delete metrics older than three months.
+
+### Time Series Database
+
+With this all said, a relational database might not be the best storage engine for this kind of data as
+
+* We will heavily write to the database which would cause to frequently create new pages in a [B-Tree](https://en.wikipedia.org/wiki/B-tree) like most relational databases use internally
+* We would need to implement some sort of garbage collection to remove old data
+* Compression of data would not be very efficient
+
+For this kind of data, a [log based storage engine](https://en.wikipedia.org/wiki/Log-structured_merge-tree) like most [Time Series databases](https://db-engines.com/en/ranking/time+series+dbms) implement it would be more efficient.
+
+However, for the sake of simplicity, we store our metrics in a relational database in this tutorial, the implementation can be found in [5967](https://github.com/ChrisBr/active_monitoring/commit/5967190a1484009476f2378c02e3e0ea96d21624).
+
+## Chapter 3: Cleaning, Normalizing and Grouping
+In the previous chapter we already stored the controller metrics.
+Before we can store SQL metrics, we need to do some more additional work.
+
+### Cleaning
+ActiveRecord does a lot of 'magic' behind the scenes to abstract persisting objects to the database.
+Some of this 'magic' requires to execute additional database queries, for instance
+
+* Current version of the database engine
+* Which migrations did already run
+* Which environment
+
+We're only interested to store application metrics so we need to filter these queries out.
+The implementation can be found in [156d](https://github.com/ChrisBr/active_monitoring/commit/156d8f7fb0bd3b013524a20effc65dad05506b3d).
+
+### Normalizing
+Depending on the database adapter you use, the queries might contain values.
+To group the same queries together, we need to normalize these queries.
+
+```SQL
+SELECT * FROM books WHERE id = 1;
+SELECT * FROM books WHERE id = 2;
+```
+
+For our performance monitoring tool, these two queries should be treated the same and we need to normalize them to
+```SQL
+SELECT * FROM books WHERE id = xxx;
+```
+
+In [66a8](https://github.com/ChrisBr/active_monitoring/commit/66a833a46b40072a8888fb6b6c6bb02ee60bda17) we implement a simple query normalizer.
+
+### Grouping
+ActiveRecord is a standalone framework, therefore the payload of the SQL event does not contain a `request_id`.
+We can use ActiveRecord for instance in migrations or background jobs so it is perfectly valid to use it outside of a request response cycle.
+However, in our Performance Monitoring tool we would like to group requests and SQL queries together so we can see if a query causes a slow response.
+
+Luckily, we also implemented a `start_processing` event in [ef20](https://github.com/ChrisBr/active_monitoring/commit/ef200ae5bf58f9afd2a69003e2c3620d0d9c86eb).
+We can now subscribe to this event and set the `request_id` and `location` in a cache which we later read
+in when writing the SQL metrics.
+In [b1f1](https://github.com/ChrisBr/active_monitoring/commit/b1f1847270935beacc236bc54535ced1eb83c5ef) we implement a `CurrentAttributes` class and eventually write the SQL metrics.
+
+ActiveSupport ships with [CurrentAttributes](https://github.com/rails/rails/blob/157920aead96865e3135f496c09ace607d5620dc/activesupport/lib/active_support/current_attributes.rb) out of the box since Rails 5.
+
+## Chapter 4: Visualization
+So we now have several metrics in our data base written which would look something like
+
+| Timestamp  | Hook | Location | Request ID | Value |
+| ------------- | ------------- |------------- |------------- |------------- |
+| 01.04.2020 00:31:30 CET | process_action | BooksController#show | cf6d6dcd | 100 ms
+| 01.04.2020 00:32:30 CET | sql | BooksController#show | c7c7c841 | 80 ms
+
+It would be very hard to spot now problems or discover pattern so eventually we need to visualize our collected data.
+In [cfca](https://github.com/ChrisBr/active_monitoring/commit/cfcafd2f4664e6927e7d297a4b7da2e18bdd5205) we implement a dashboard to show percentiles and the slowest queries of our Rails app.
+A very good blog article about data visualization for performance metrics from Richard Schneemann can be found [here](https://www.schneems.com/2020/03/17/lies-damned-lies-and-averages-perc50-perc95-explained-for-programmers/).
+
+In a real world application, I would strongly recommend to use a dashboard software like [Grafana](https://github.com/grafana/grafana).
+
+## Summary
+Congratulations, we implemented a very basic Performance Monitoring tool in just a few hundred lines of code now.
+We deep dived into [ActiveSupport Notifications](https://edgeguides.rubyonrails.org/active_support_instrumentation.html) and hooked into Rails events to write request and SQL query metrics in our data storage.
+As data storage, we compared relational databases with time series databases like InfluxDB.
+Before we could visualize our data, we needed to clean, normalize and group the metrics.
+
+From here, we can easily add more metrics like [rendering of views](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#action-view), 
+[caching](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#active-support) or [background jobs](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#active-job).
+
+As initially mentioned, this tutorial is heavily influenced by our work on https://github.com/influxdata/influxdb-rails.
+If this made you curious, we always look for new contributors.
+
+## Further information
+* [Profiling and Benchmarking 101 by Nate Berkopec](https://youtu.be/XL51vf-XBTs)
+* [Lies, Damned Lies, and Averages: Perc50, Perc95 explained for Programmers by Richard Schneeman](https://www.schneems.com/2020/03/17/lies-damned-lies-and-averages-perc50-perc95-explained-for-programmers/)
+* https://github.com/influxdata/influxdb-ruby
+* https://github.com/influxdata/influxdb-rails
+* https://docs.influxdata.com/influxdb/v1.7/concepts/storage_engine/
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+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    = "ActiveMonitoring"
+  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", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/active_monitoring/application_controller.rb

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

data/app/controllers/active_monitoring/dashboard_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "active_monitoring/application_controller"
+
+module ActiveMonitoring
+  class DashboardController < ApplicationController
+    def show
+      @dashboard = Dashboard.new
+    end
+  end
+end

data/app/models/active_monitoring/application_record.rb

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

data/app/models/active_monitoring/dashboard.rb

@@ -0,0 +1,33 @@
+module ActiveMonitoring
+  class Dashboard
+    LIMIT = 10
+
+    def initialize(date = Date.current)
+      @date = date
+    end
+
+    def percentile(value)
+      response_metrics.percentile(value)
+    end
+
+    def slow_sql_queries
+      sql_metrics.order(:value).limit(LIMIT)
+    end
+
+    private
+
+      attr_reader :date
+
+      def sql_metrics
+        metrics.where(name: "sql.active_record")
+      end
+
+      def response_metrics
+        metrics.where(name: "process_action.action_controller")
+      end
+
+      def metrics
+        Metric.where(created_at: date.beginning_of_day..date.end_of_day)
+      end
+  end
+end

data/app/models/active_monitoring/metric.rb

@@ -0,0 +1,7 @@
+module ActiveMonitoring
+  class Metric < ApplicationRecord
+    def self.percentile(value)
+      order(:value).offset(count * value / 10 - 1).limit(1).pluck(:value).first
+    end
+  end
+end

data/app/views/active_monitoring/dashboard/show.html.erb

@@ -0,0 +1,23 @@
+<h1>Dashboard</h1>
+
+<h2>Response time</h2>
+<ul>
+  <li>90th Percentile: <%= @dashboard.percentile(9) %><li>
+  <li>50th Percentile: <%= @dashboard.percentile(5) %><li>
+</ul>
+
+<h2>Slow queriess</h2>
+<table>
+  <tr>
+    <th>SQL</th>
+    <th>Location</th>
+    <th>Time</th>
+  </tr>
+  <% @dashboard.slow_sql_queries.each do |metric| %>
+  <tr>
+    <td><%= metric.sql_query %></td>
+    <td><%= metric.location %></td>
+    <td><%= metric.value %></td>
+  </tr>
+  <% end %>
+<table>

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

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Active monitoring</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,3 @@
+ActiveMonitoring::Engine.routes.draw do
+  resource :dashboard, controller: :dashboard, only: :show
+end

data/db/migrate/20200401191741_create_active_monitoring_metrics.rb

@@ -0,0 +1,13 @@
+class CreateActiveMonitoringMetrics < ActiveRecord::Migration[6.0]
+  def change
+    create_table :active_monitoring_metrics do |t|
+      t.string :name
+      t.string :request_id
+      t.string :location
+      t.string :sql_query
+      t.integer :value
+
+      t.timestamps
+    end
+  end
+end

data/lib/active_monitoring.rb

@@ -0,0 +1,6 @@
+require "active_monitoring/engine"
+require "active_monitoring/notifications"
+
+module ActiveMonitoring
+  # Your code goes here...
+end

data/lib/active_monitoring/core_extensions/action_controller.rb

@@ -0,0 +1,19 @@
+module ActiveMonitoring
+  module CoreExtensions
+    module ActionController
+      module Instrumentation
+        def process_action(*)
+          payload = {
+            controller: self.class.name,
+            action: action_name,
+            request_id: request.uuid
+          }
+          ::ActiveMonitoring::Notifications.instrument("start_processing.action_controller", payload)
+          ::ActiveMonitoring::Notifications.instrument("process_action.action_controller", payload) do
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_monitoring/core_extensions/active_record.rb

@@ -0,0 +1,13 @@
+module ActiveMonitoring
+  module CoreExtensions
+    module ActiveRecord
+      module Instrumentation
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          ::ActiveMonitoring::Notifications.instrument("sql.active_record", sql: sql, name: name) do
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_monitoring/current.rb

@@ -0,0 +1,31 @@
+require_relative "core_extensions/action_controller"
+require_relative "core_extensions/active_record"
+require_relative "sql_query"
+require_relative "current"
+
+module ActiveMonitoring
+  class Current
+    class << self
+      def request_id
+        store[:request_id]
+      end
+
+      def request_id=(value)
+        store[:request_id] = value
+      end
+
+      def location
+        store[:location]
+      end
+
+      def location=(value)
+        store[:location] = value
+      end
+
+      def store
+        Thread.current[:active_monitoring_store] ||= {}
+        Thread.current[:active_monitoring_store]
+      end
+    end
+  end
+end

data/lib/active_monitoring/engine.rb

@@ -0,0 +1,47 @@
+require_relative "core_extensions/action_controller"
+require_relative "core_extensions/active_record"
+require_relative "sql_query"
+require_relative "current"
+
+module ActiveMonitoring
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveMonitoring
+
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(::ActiveMonitoring::CoreExtensions::ActiveRecord::Instrumentation)
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.prepend(::ActiveMonitoring::CoreExtensions::ActionController::Instrumentation)
+
+      ActiveMonitoring::Notifications.subscribe("start_processing.action_controller") do |_, _, _, _, payload|
+        Current.request_id = payload[:request_id]
+        Current.location = "#{payload[:controller]}##{payload[:action]}"
+      end
+
+      ActiveMonitoring::Notifications.subscribe("process_action.action_controller") do |name, start, finish, _id, payload|
+        Metric.create(
+          name: name,
+          value: finish - start,
+          request_id: payload[:request_id],
+          location: "#{payload[:controller]}##{payload[:action]}",
+          created_at: finish
+        )
+      end
+
+      ActiveMonitoring::Notifications.subscribe("sql.active_record") do |name, start, finish, _id, payload|
+        query = ActiveMonitoring::SqlQuery.new(name: payload[:name].dup, query: payload[:sql].dup)
+        if query.track?
+          Metric.create(
+            name: name,
+            value: finish - start,
+            request_id: Current.request_id,
+            sql_query: query.normalized_query,
+            location: Current.location,
+            created_at: finish
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_monitoring/notifications.rb

@@ -0,0 +1,19 @@
+require_relative "notifier"
+
+module ActiveMonitoring
+  class Notifications
+    class << self
+      attr_accessor :notifier
+
+      def subscribe(name, &block)
+        notifier.subscribe(name, &block)
+      end
+
+      def instrument(name, payload = {}, &block)
+        notifier.instrument(name, payload, &block)
+      end
+    end
+
+    self.notifier = ActiveMonitoring::Notifier.new
+  end
+end

data/lib/active_monitoring/notifier.rb

@@ -0,0 +1,33 @@
+module ActiveMonitoring
+  class Notifier
+    def initialize
+      @subscribers = {}
+    end
+
+    def subscribe(name, &block)
+      subscribers[name] ||= []
+      subscribers[name] << block
+    end
+
+    def instrument(name, payload)
+      id = SecureRandom.hex(10)
+      start = Time.current
+      result = yield if block_given?
+      finish = Time.current
+
+      subscribers_for(name).each do |callback|
+        callback.call(name, start, finish, id, payload)
+      end
+
+      result
+    end
+
+    private
+
+      attr_reader :subscribers
+
+      def subscribers_for(name)
+        subscribers[name].to_a
+      end
+  end
+end

data/lib/active_monitoring/sql_normalizer.rb

@@ -0,0 +1,23 @@
+module ActiveMonitoring
+  class SqlNormalizer
+    def initialize(query:)
+      @query = query
+    end
+
+    def to_s
+      query.squish!
+      query.gsub!(/(\s(=|>|<|>=|<=|<>|!=)\s)('[^']+'|[\$\+\-\w\.]+)/, '\1xxx')
+      query.gsub!(/(\sIN\s)\([^\(\)]+\)/i, '\1(xxx)')
+      regex = /(\sBETWEEN\s)('[^']+'|[\+\-\w\.]+)(\sAND\s)('[^']+'|[\+\-\w\.]+)/i
+      query.gsub!(regex, '\1xxx\3xxx')
+      query.gsub!(/(\sVALUES\s)\(.+\)/i, '\1(xxx)')
+      query.gsub!(/(\s(LIKE|ILIKE|SIMILAR TO|NOT SIMILAR TO)\s)('[^']+')/i, '\1xxx')
+      query.gsub!(/(\s(LIMIT|OFFSET)\s)(\d+)/i, '\1xxx')
+      query
+    end
+
+    private
+
+      attr_reader :query
+  end
+end

data/lib/active_monitoring/sql_query.rb

@@ -0,0 +1,23 @@
+require_relative "sql_tracker"
+require_relative "sql_normalizer"
+
+module ActiveMonitoring
+  class SqlQuery
+    def initialize(query:, name:)
+      @query = query
+      @name = name
+    end
+
+    def track?
+      SqlTracker.new(query: query, name: name).track?
+    end
+
+    def normalized_query
+      SqlNormalizer.new(query: query).to_s
+    end
+
+    private
+
+      attr_reader :query, :name
+  end
+end

data/lib/active_monitoring/sql_tracker.rb

@@ -0,0 +1,33 @@
+module ActiveMonitoring
+  class SqlTracker
+    TRACKED_SQL_COMMANDS = %w(SELECT INSERT UPDATE DELETE).freeze
+    UNTRACKED_NAMES = %w(SCHEMA).freeze
+    UNTRACKED_TABLES = %w(
+      SCHEMA_MIGRATIONS
+      SQLITE_MASTER
+      ACTIVE_MONITORING_METRICS
+      SQLITE_TEMP_MASTER
+      SQLITE_VERSION
+      AR_INTERNAL_METADATA
+    ).freeze
+
+    def initialize(query:, name:)
+      @query = query.to_s.upcase
+      @name = name.to_s.upcase
+    end
+
+    def track?
+      query.start_with?(*TRACKED_SQL_COMMANDS) &&
+        !name.start_with?(*UNTRACKED_NAMES) &&
+        !untracked_tables?
+    end
+
+    private
+
+      attr_reader :query, :name
+
+      def untracked_tables?
+        UNTRACKED_TABLES.any? { |table| query.include?(table) }
+      end
+  end
+end

data/lib/active_monitoring/version.rb

@@ -0,0 +1,3 @@
+module ActiveMonitoring
+  VERSION = "0.1.0".freeze
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: active_monitoring
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christian Bruckmayer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.2.2
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: rubocop-performance
+  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: rubocop-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: 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'
+description: his is an example gem used in my RailsConf 2020 talk. Please don't use
+  in production! https://bruckmayer.net/rails-conf-2020
+email:
+- christian@bruckmayer.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/active_monitoring/application_controller.rb
+- app/controllers/active_monitoring/dashboard_controller.rb
+- app/models/active_monitoring/application_record.rb
+- app/models/active_monitoring/dashboard.rb
+- app/models/active_monitoring/metric.rb
+- app/views/active_monitoring/dashboard/show.html.erb
+- app/views/layouts/active_monitoring/application.html.erb
+- config/routes.rb
+- db/migrate/20200401191741_create_active_monitoring_metrics.rb
+- lib/active_monitoring.rb
+- lib/active_monitoring/core_extensions/action_controller.rb
+- lib/active_monitoring/core_extensions/active_record.rb
+- lib/active_monitoring/current.rb
+- lib/active_monitoring/engine.rb
+- lib/active_monitoring/notifications.rb
+- lib/active_monitoring/notifier.rb
+- lib/active_monitoring/sql_normalizer.rb
+- lib/active_monitoring/sql_query.rb
+- lib/active_monitoring/sql_tracker.rb
+- lib/active_monitoring/version.rb
+homepage: https://github.com/ChrisBr/active_monitoring
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: This is an example gem used in my RailsConf 2020 talk. Please don't use in
+  production!
+test_files: []