kenny 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39b86e8b4853fcce4fcb7d38127b6f59321c5b17
+  data.tar.gz: c75ef30aede10e34de737316384e5d5b4badc120
+SHA512:
+  metadata.gz: ba32367e5f63c0f2577cb0895ac85d8a5dc97bfc99669bc7bcb08eca0082c6bda5a383784cd2d131a3ead4c66803a6281eb08fd54cf3c327d15f4802ab8e6126
+  data.tar.gz: c66a0f075bb3369eef09529e632b71ea6d3f56b076f05e3c8286358662bcbff9b23cbde9233511a5d655e77f2e427df82a9b24e1dc84d2944442ad1f6a3a0154

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2016 FromAtoB.com http://fromatob.com
+
+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,184 @@
+# Kenny
+Inspired by [lograge](https://github.com/roidrage/lograge), but without the rage. And logs are optional.
+
+Lograge does a great job in suppressing Rails' log output, it does so by:
+- overriding Rails' default behaviour for instrumentations/subscriptions
+- being very opinionated, hence removing a lot of data from your log.
+
+As a result, even though Lograge is great for cleaning your production.log, it is neither meant for collecting metrics nor great for plugging into any instrumentation event that you want.
+
+Kenny attempts to leave implementations to the user and provide a more modular way to monitor instrumentation events.
+It allows the user to decide:
+- which instrumentations to monitor
+- what to do when the specified instrumentation event occurs
+- where to log the data to (or no logging to file at all)
+- whether or not to unsubscribe from Rails' default instrumentations (although not recommended)
+
+Apart from that, it was also created with the idea of keeping all subscribed events in one place. So it will keep your code clean and provide a nice overview of all event-triggered actions.
+
+Best to be explained with an example.
+
+## Installation
+
+Gemfile:
+
+```ruby
+gem 'kenny'
+```
+
+And then execute:
+
+    $ bundle
+
+Or command line:
+
+    $ gem install kenny
+
+## Usage
+  Kenny can be configured through an initializer (`config/initializers/kenny.rb`) or within the configuration file of your environment `development|test|staging|production.rb`.
+  This depends on whether you want to have the same behaviour or different behaviours accross environments.
+
+  If you do configure Kenny through an initializer, then it would give you the advantage of keeping all your instrumentation configurations in one place.
+
+  Here is an example, its details will be explained in the following paragraphs.
+
+  ```ruby
+  # Example
+  MyApp::Application.configure do
+    # Define a logger-instance with formatter to be used later
+    request_logger = ActiveSupport::Logger.new( File.join(Rails.root, "log", "process_action.log") )
+    log_stash_formatter = Kenny::Formatters::LogStashFormatter.new
+    request_logger.formatter = log_stash_formatter
+
+    config.kenny.unsubscribe_rails_defaults = false
+    config.kenny.suppress_rack_logger = true
+    config.kenny.instrumentations = [
+      { name: 'process_action.action_controller',
+        block: lambda do |event|
+          data = MyDataBuilder.build(event)
+          logger.info("#{event.name}: #{data}")
+        end,
+       logger: request_logger
+      },
+      { name: 'sql.active_record',
+        block: lambda do |event|
+          data = event.payload
+          Rails.logger.info("#{event.name}: #{data}")
+        end
+      }
+    ]
+
+  end
+
+  ```
+
+
+### `kenny.instrumentations` configuration
+  Before proceeding, have a look at [Active Support Instrumentation](http://edgeguides.rubyonrails.org/active_support_instrumentation.html) and [LogSubscriber](http://api.rubyonrails.org/classes/ActiveSupport/LogSubscriber.html)
+
+  The `kenny.instrumentations` configuration takes an array of hashes. Each hash represents a Rails instrumentation event that you want to subscribe to.
+
+  Each of these hashes requires a `:name` (name of instrumentation event), a `:block` (what to do when that event occurs) and *optionally* a `:logger` (which logger to use in order to write these events to a file).
+
+  In the example above, we setup Kenny to monitor two instrumentation events, `process_action.action_controller` and `sql.active_record`.
+
+  Behind the scenes, it defines an anonymous class (< ActiveSupport::LogSubscriber) for each of the specified instrumentations.
+
+  The first one gets method `def process_action` defined and `def logger` *redefined*.
+
+  The body of `def process_action` is the `:block` that has been supplied to the configuration.
+  Hence, `:block` must be a Lambda or a Proc.
+  (Lambda will raise errors with wrong number of arguments, Proc won't)
+
+  The `def logger` method (in ActiveSupport::LogSubscriber) gets overridden and will return the logger-instance that you have provided to the configuration. (In this case, it's the logger instance `request_logger` that you have defined at the top of your config).
+
+  This class is then attached to :action_controller, by looking up the event name 'process_action.action_controller'
+
+  The idea of redefining `def logger` may sound a bit scary, but this is necessary to keep events from
+  different instrumentation channels on different log files. If `:logger` option is not provided, then that LogSubscriber class will use the default Rails logger (and hence write to your production.log etc)
+
+  The second LogSubscriber class will have method `def start_processing` defined and the method body is again what has been supplied in the :block configuration.
+
+  The difference is that `:logger` has not been provided, hence it won't override the logger method for this LogSubscriber. In Rails, this means it will fall back to the default `Rails.logger`.
+  Mind you that even though a LogSubscriber has access to a logger, it does not mean you have to use it! There is nothing wrong with subscribing to an event and not log its data to file at all! There are other things you could do with this data.
+  At the end, this class gets attached to :active_record, by looking up the event name 'sql.active_record'
+
+#### Be careful with variable scopes and lambdas
+  Since lambdas are used to define method bodies, be careful with context of variables.
+  Take the example below:
+
+  ``` Ruby
+  # Somewhere above the instrumentation configurations
+  logger = ActiveSupport::Logger.new( File.join(Rails.root, "log", "process_action.log") )
+
+  # Then within the instrumentation configuration
+  config.kenny.instrumentations = [
+    { name: 'sql.active_record',
+      block: lambda do |event|
+        data = event.payload
+        logger.info("#{event.name}: #{data}")
+      end
+    }
+  ]
+  ```
+
+  You might think that since no `:logger` option has been provided for 'sql.active_record' events, the default logger will be used..... But that is not true.
+  Since `logger` is within scope at the time when the lambda was defined, this instance of ActiveSupport::Logger will be used to invoke `#info` when 'sql.active_record' occurs. So just avoid creating a local variable that have the same name as variables in your block.
+
+
+### `kenny.unsubscribe_rails_defaults` configuration
+  Kenny can also used to unsubscribe all Rails LogSubscribers from their subscribed instrumentation events.
+  You can do that by setting `:unsubscribe_rails_defaults` to true:
+
+  ``` Ruby
+  config.kenny.unsubscribe_rails_defaults = true
+  config.kenny.instrumentations = [{
+      # your stuff
+    }]
+  }
+  ```
+
+  By doing so, your `development|test|staging|production.log` will not have any of the default log messages. This is not an approach I would recommend, unless you are desperate to have all messages from your specified instrumentation events all logged into one `development|test|staging|production.log`.
+
+
+### `kenny.suppress_rack_logger` configuration
+  By default, your rails app logs messages like these to your environment's log:
+
+  ```
+  Started GET "/my_path" for 10.0.2.2 at 2016-07-12 10:06:48 +0000
+  Started GET "/assets/sh/my_styles.css?body=1" for 10.0.2.2 at 2016-07-12 10:06:49 +0000
+  ```
+
+  You can suppress these messages by setting kenny.suppress_rack_logger to true.
+  This setting will not have any effects on the log files that you create separately with the `:logger` option within your specified instrumentation.
+
+## Open-to-Implementation approach
+  As you might have seen from the example, the `:block` allows you to define your own implementation.
+  The idea behind writing this gem is to free up users from the tedious task of defining LogSubscriber classes and to allow them to define whatever they wants to do with the event data, be it something like:
+
+  ```Ruby
+    config.kenny.instrumentations = [
+      { name: 'process_action.action_controller',
+        block: lambda do |event|
+          data = MyDataBuilder.build(event)
+           # Use Fluent to send data to another server
+          Fluent::Logger::FluentLogger.open(nil, :host=>MY_SERVER, :port=>24224)
+          Fluent::Logger.post('web_requests', data)
+        end
+      },
+      { name: 'sql.active_record',
+        block: lambda do |event|
+          data = MyDataBuilder.build(event)
+          # Do something asynchronously, maybe send to an external service
+          Something.async.process_and_forward(data)
+        end
+      }
+    ]
+  ```
+
+  Again, there is no requirement for you to write messages to log files. It is all up to you.
+
+## Formatters
+  Apart from subscribing to instrumentation events and logging, Kenny also provides formatters, which you can attach to a logger.
+
+  Currently, it only comes with a LogStashFormatter, but feel free to add more Formatters to make this project great.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/kenny/formatters/log_stash_formatter.rb

@@ -0,0 +1,30 @@
+require 'logger'
+require 'logstash-event'
+require 'active_support'
+
+module Kenny
+  module Formatters
+    class LogStashFormatter < ::Logger::Formatter
+
+      include ActiveSupport::TaggedLogging::Formatter
+
+      def call(severity, time, progname, msg)
+        msg = { 'message' => msg.is_a?(String) ? msg : msg.inspect } unless msg.is_a?(Hash)
+
+        msg['severity'] = severity if severity
+        msg['progname'] = progname if progname
+
+        tags = current_tags
+
+        if tags.size > 0
+          msg['type'] ||= tags.first
+          msg['tags'] = tags
+        end
+
+        event = LogStash::Event.new(msg)
+
+        "%s\n" % event.to_json
+      end
+    end
+  end
+end

data/lib/kenny/log_subscriber.rb

@@ -0,0 +1,11 @@
+## 
+# This class is meant to be inherited by anonymous classes, 
+# created through Kenny.define_log_subscriber_class.
+#
+# By inserting this class into the inheritance tree, 
+# we can verify in test-environment whether the LogSubscribers 
+# we created are indeed attached to the instrumentations we specified.
+module Kenny
+  class LogSubscriber < ActiveSupport::LogSubscriber
+  end
+end

data/lib/kenny/rails_ext/rack/logger.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    # Overwrites defaults of Rails::Rack::Logger that cause
+    # unnecessary logging.
+    # This effectively removes the log lines from the log
+    # that say:
+    # Started GET / for 192.168.2.1...
+    class Logger
+      # Overwrites Rails 3.2 code that logs new requests
+      def call_app(*args)
+        env = args.last
+        @app.call(env)
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Overwrites Rails 3.0/3.1 code that logs new requests
+      def before_dispatch(_env)
+      end
+    end
+  end
+end

data/lib/kenny/railtie.rb

@@ -0,0 +1,27 @@
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+require 'active_record/log_subscriber'
+require 'action_mailer/log_subscriber'
+
+module Kenny
+  class Railtie < Rails::Railtie
+    config.kenny = Kenny.configs
+
+    config.after_initialize do |app|
+      Kenny.application = app
+
+      # Define anonymous classes that inherit from ActiveSupport::LogSubscriber.
+      # Within that anonymous class, define methods that
+      # perform the user-defined actions when that instrumentation occurs.
+      # If desired, user can define a specific logger for the specified instrumentation.
+      Kenny.attach_to_instrumentations
+
+      # Unsubscribe all default Rails LogSubscribers if demanded
+      Kenny.unsubscribe_from_rails_defaults
+
+      # Suppress Rails::Rack::Logger's output
+      Kenny.suppress_rack_logger
+    end
+  end
+end

data/lib/kenny/unsubscriber.rb

@@ -0,0 +1,60 @@
+##
+# Module to unsubscribe all Rails default LogSubscribers from their events.
+module Kenny
+  module Unsubscriber
+    DEFAULT_RAILS_LOG_SUBSCRIBER_CLASSES = [
+      ActionView::LogSubscriber, 
+      ActionController::LogSubscriber, 
+      ActiveRecord::LogSubscriber, 
+      ActionMailer::LogSubscriber
+    ]
+
+    ##
+    # By default, a Rails app instantiates the LogSubscribers listed above and
+    # are actively listening to instrumentations listed in:
+    # http://edgeguides.rubyonrails.org/active_support_instrumentation.html
+    # 
+    # Unsubscribing is not recommended, unless you want to modify the output
+    # to your standard rails logs (development|test|staging|production).log
+    # 
+    # It would be safer to write your chosen instrumentation data to a separate file,
+    # setup by the [:logger] configuration (see Readme). In that case, the [:unsubscribe_rails_defaults]
+    # field in Kenny's config won't need to be set.
+    def self.unsubscribe_from_rails_defaults
+      default_rails_log_subscribers.each do |subscriber|
+        subscribed_events_for(subscriber).each do |event|
+          unsubscribe_listeners_for_event(subscriber, event)
+        end
+      end
+    end
+
+    def self.default_rails_log_subscribers
+      ActiveSupport::LogSubscriber.log_subscribers.select do |subscriber|
+        DEFAULT_RAILS_LOG_SUBSCRIBER_CLASSES.include? subscriber.class
+      end
+    end
+    private_class_method :default_rails_log_subscribers
+
+    def self.listeners_for(event, subscriber_namespace)
+      ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{subscriber_namespace}")
+    end
+    private_class_method :listeners_for
+
+    def self.unsubscribe_listeners_for_event(subscriber, event)
+      subscriber_namespace = subscriber.class.send :namespace
+      listeners_for(event, subscriber_namespace).each do |listener|
+        if listener.instance_variable_get('@delegate') == subscriber
+          ActiveSupport::Notifications.unsubscribe listener
+        end
+      end
+    end
+    private_class_method :unsubscribe_listeners_for_event
+
+    def self.subscribed_events_for(subscriber)
+      error_msg = "Expected #{subscriber} to be inherited from ActiveSupport::LogSubscriber"
+      raise error_msg if subscriber.class.superclass != ActiveSupport::LogSubscriber
+      subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+    end
+    private_class_method :subscribed_events_for
+  end
+end

data/lib/kenny.rb

@@ -0,0 +1,84 @@
+##
+# Kenny module does three things:
+# - Holds reference to the Rails application (set through Railtie)
+# - Unsubscribe all Rails' LogSubscribers from the default instrumentation channels
+# - Create LogSubscriber-classes which will be attached to the user-specified instrumentations
+
+module Kenny
+
+  def self.configs
+    Struct.new(
+      :unsubscribe_rails_defaults,
+      :suppress_rack_logger,
+      :instrumentations
+    ).new
+  end
+
+  def self.application=(app)
+    @@application = app
+  end
+
+  def self.application
+    @@application
+  end
+
+  ##
+  # Define LogSubscriber-classes and Attach to user-specified instrumentations
+  # if the configurations have been set.
+  def self.attach_to_instrumentations
+    if @@application.config.kenny[:instrumentations]
+      @@application.config.kenny[:instrumentations].each do |instr_config|
+        define_log_subscriber_class(instr_config)
+      end
+    end
+  end
+
+  ##
+  # Unsubscribe all Rails' default LogSubscribers from the default Rails instrumentations,
+  # by delegating to Kenny::Unsubscriber.
+  # See http://edgeguides.rubyonrails.org/active_support_instrumentation.html
+  def self.unsubscribe_from_rails_defaults
+    if @@application.config.kenny[:unsubscribe_rails_defaults]
+      Kenny::Unsubscriber.unsubscribe_from_rails_defaults
+    end
+  end
+
+  ##
+  # Suppress Rails::Rack::Logger's output à la
+  #   Started GET "/my_path" for 10.0.2.2 at 2016-07-12 10:06:48 +0000
+  def self.suppress_rack_logger
+    if @@application.config.kenny[:suppress_rack_logger]
+      require "kenny/rails_ext/rack/logger"
+    end
+  end
+
+  ##
+  # Create LogSubscriber-classes which will be attached to the user-specified instrumentations
+  # These classes are anonymous, but inherit from Kenny::LogSubscriber to simplify testing
+  #
+  # Within these classes, methods (and potentially `def logger`) are defined based on the
+  # instrumentations-configs provided by the user.
+  def self.define_log_subscriber_class(instr_config)
+    klass = Class.new(Kenny::LogSubscriber) do |k|
+      define_method( instr_config[:name].split(".")[0], instr_config[:block] )
+
+      if instr_config[:logger]
+        # Following assignment needed as we don't want to have
+        # the lambda being re-evaluated and possibly return
+        # a new logger instance everytime the .logger method is invoked.
+        defined_logger = instr_config[:logger]
+        define_method(:logger, lambda{defined_logger})
+      end
+
+    end
+    klass.attach_to instr_config[:name].split(".")[1].to_sym
+  end
+  private_class_method :define_log_subscriber_class
+
+end
+
+require "kenny/railtie"
+
+require "kenny/formatters/log_stash_formatter"
+require "kenny/unsubscriber"
+require "kenny/log_subscriber"

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: kenny
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Mathias Rüdiger, Alex Fong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: logstash-event
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.02
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.02
+description: Kenny acts as a one-stop destination for defining which Rails instrumentations
+  you want to monitor and what to do when they occur.
+email:
+- mathias.ruediger@fromatob.com, alex.fong@fromatob.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/kenny.rb
+- lib/kenny/formatters/log_stash_formatter.rb
+- lib/kenny/log_subscriber.rb
+- lib/kenny/rails_ext/rack/logger.rb
+- lib/kenny/railtie.rb
+- lib/kenny/unsubscriber.rb
+homepage: https://github.com/fromAtoB/kenny
+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: Monitor and act upon Rails instrumentation events.
+test_files: []