datadog-notifications 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fadcae3b1ef25818ba7aa40d9da48019e1ce3f40
+  data.tar.gz: b64e1b4672ed2cfaea03590f1ba4fd7e1e6e2d1e
+SHA512:
+  metadata.gz: b4fb5671f2f94651db09531be28a407eddb4ab75cbcc8ccf36639fd01d40acd4eec2c335d4cd365c5611531c688b742b34871b73014440272c759ce894e4e505
+  data.tar.gz: a7ae41851bfbbb16463b6f73d92f3e548147d22691819e6afd7416edb33a7669f501dba35ef268c3f7797f199ac41fdcb70fe4faaabbd8487653ab166d7be98d

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3

data/Gemfile

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

data/MIT-LICENCE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Black Square Media
+
+MIT License
+
+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,34 @@
+datadog-notifications
+=====================
+
+Datadog intrumentation for [ActiveSupport::Notifications](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'datadog-notifications'
+
+Or install:
+
+    $ gem install datadog-notifications
+
+Configure it in an initializer:
+
+    Datadog::Notifications.configure do |c|
+      c.hostname = "my-host"
+      c.tags     = ["my:tag"]
+
+      c.use Datadog::Notifications::Plugins::ActionController
+      c.use Datadog::Notifications::Plugins::ActiveRecord, tags: ["more:tags"]
+    end
+
+For full configuration options, please see the [Documentation](http://www.rubydoc.info/gems/datadog-notifications).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Make a pull request

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/datadog-notifications.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'datadog/notifications/version'
+
+Gem::Specification.new do |s|
+  s.name          = "datadog-notifications"
+  s.version       = Datadog::Notifications::VERSION.dup
+  s.authors       = ["Dimitrij Denissenko"]
+  s.email         = ["dimitrij@blacksquaremedia.com"]
+  s.description   = %q{Datadog instrumnetation for ActiveSupport::Notifications}
+  s.summary       = %q{Generic ActiveSupport::Notifications Datadog handler}
+  s.homepage      = "https://github.com/bsm/datadog-notifications"
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(spec)/})
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency(%q<activesupport>)
+  s.add_runtime_dependency(%q<dogstatsd-ruby>)
+
+  s.add_development_dependency(%q<rack-test>)
+  s.add_development_dependency(%q<grape>)
+  s.add_development_dependency(%q<sqlite3>)
+  s.add_development_dependency(%q<activerecord>)
+  s.add_development_dependency(%q<rake>)
+  s.add_development_dependency(%q<bundler>)
+  s.add_development_dependency(%q<rspec>)
+end

data/lib/datadog-notifications.rb

@@ -0,0 +1 @@
+require "datadog/notifications"

data/lib/datadog/notifications.rb

@@ -0,0 +1,77 @@
+require 'statsd'
+require 'socket'
+require 'singleton'
+require 'active_support/notifications'
+require 'active_support/core_ext/string/inflections'
+
+require 'datadog/notifications/version'
+require 'datadog/notifications/reporter'
+require 'datadog/notifications/config'
+require 'datadog/notifications/plugins'
+
+module Datadog
+  class Notifications
+    include Singleton
+
+    # Configure and install datadog instrumentation. Example:
+    #
+    #   Datadog::Notifications.configure do |c|
+    #     c.hostname = "my-host"
+    #     c.tags     = ["app:mine"]
+    #
+    #     c.use Datadog::Notifications::Plugins::Grape, metric_name: "api.request", tags: ["grape:specific"]
+    #   end
+    #
+    # Settings:
+    # * <tt>hostname</tt>     - the hostname used for instrumentation, defaults to system hostname, respects +INSTRUMENTATION_HOSTNAME+ env variable
+    # * <tt>namespace</tt>    - set a namespace to be prepended to every metric name
+    # * <tt>tags</tt>         - set an array of tags to be added to every metric
+    # * <tt>statsd_host</tt>  - the statsD host, defaults to "localhost", respects +STATSD_HOST+ env variable
+    # * <tt>statsd_port</tt>  - the statsD port, defaults to 8125, respects +STATSD_PORT+ env variable
+    # * <tt>reporter</tt>     - custom reporter class, defaults to `Datadog::Notifications::Reporter`
+    def self.configure(&block)
+      if instance.instance_variable_defined?(:@reporter)
+        warn "#{self.name} cannot be reconfigured once it has subscribed to notifications, called from: #{caller[1]}"
+        return
+      end
+      block.call instance.config if block
+    end
+
+    # You can subscribe to events exactly as with ActiveSupport::Notifications, but there will be an
+    # additional `statsd` block parameter available:
+    #
+    #   Datadog::Notifications.subscribe('render') do |reporter, event|
+    #     reporter # => Reporter instance
+    #     event    # => ActiveSupport::Notifications::Event object
+    #   end
+    #
+    # Example:
+    #
+    #   Datadog::Notifications.subscribe('render') do |reporter, _, start, finish, _, payload|
+    #     status = payload[:status]
+    #     reporter.seconds('myapp.render', finish-start, tags: ["status:#{status}"])
+    #   end
+    #
+    def self.subscribe(pattern, &block)
+      instance.subscribe(pattern, &block)
+    end
+
+    attr_reader :config
+
+    def initialize
+      @config = Config.new
+    end
+
+    def subscribe(pattern, &block)
+      ActiveSupport::Notifications.subscribe(pattern) do |*args|
+        block.call reporter, ActiveSupport::Notifications::Event.new(*args)
+      end
+    end
+
+    def reporter
+      @reporter ||= config.send(:connect!)
+    end
+    private :reporter
+
+  end
+end

data/lib/datadog/notifications/config.rb

@@ -0,0 +1,35 @@
+module Datadog
+  class Notifications
+    class Config
+      attr_accessor :hostname, :namespace, :tags, :statsd_host, :statsd_port, :reporter
+
+      def initialize
+        @hostname    = ENV['INSTRUMENTATION_HOSTNAME'] || Socket.gethostname
+        @statsd_host = ENV['STATSD_HOST'] || ::Statsd::DEFAULT_HOST
+        @statsd_port = (ENV['STATSD_PORT'] || ::Statsd::DEFAULT_PORT).to_i
+        @reporter    = Datadog::Notifications::Reporter
+        @tags        = []
+        @plugins     = []
+      end
+
+      # Use a plugin
+      def use(klass, opts = {})
+        @plugins.push [klass, opts]
+      end
+
+      def connect!
+        @plugins.each do |klass, opts|
+          klass.new(opts)
+        end
+
+        env = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+        tags.push("env:#{env}")       if env && tags.none? {|t| t =~ /^env\:/ }
+        tags.push("host:#{hostname}") if tags.none? {|t| t =~ /^host\:/ }
+
+        reporter.new statsd_host, statsd_port, namespace: namespace, tags: tags
+      end
+      protected :connect!
+
+    end
+  end
+end

data/lib/datadog/notifications/plugins.rb

@@ -0,0 +1,10 @@
+module Datadog
+  class Notifications
+    module Plugins
+    end
+  end
+end
+
+%w|base grape active_record active_job action_controller|.each do |name|
+  require "datadog/notifications/plugins/#{name}"
+end

data/lib/datadog/notifications/plugins/action_controller.rb

@@ -0,0 +1,39 @@
+module Datadog::Notifications::Plugins
+  class ActionController < Base
+
+    attr_reader :metric_name
+
+    # Options:
+    #
+    # *<tt>:metric_name</tt> - the metric name, defaults to "rails.request"
+    # *<tt>:tags</tt> - additional tags
+    def initialize(opts = {})
+      super
+      @metric_name = opts[:metric_name] || "rails.request"
+
+      Datadog::Notifications.subscribe 'process_action.action_controller' do |reporter, event|
+        record reporter, event
+      end
+    end
+
+    private
+
+    def record(reporter, event)
+      payload = event.payload
+      method  = payload[:method].downcase
+      status  = payload[:status]
+      action  = payload[:action]
+      ctrl    = payload[:controller].sub(/Controller$/, '').underscore
+      format  = payload[:format]
+      tags    = self.tags + %W|method:#{method} status:#{status} action:#{action} controller:#{ctrl} format:#{format}|
+
+      reporter.batch do
+        reporter.increment metric_name, tags: tags
+        reporter.timing "#{metric_name}.time", event.duration, tags: tags
+        reporter.timing "#{metric_name}.time.db", to_millis(payload[:db_runtime]), tags: tags
+        reporter.timing "#{metric_name}.time.view", to_millis(payload[:view_runtime]), tags: tags
+      end
+    end
+
+  end
+end

data/lib/datadog/notifications/plugins/active_job.rb

@@ -0,0 +1,33 @@
+module Datadog::Notifications::Plugins
+  class ActiveJob < Base
+
+    attr_reader :metric_name
+
+    # Options:
+    #
+    # *<tt>:metric_name</tt> - the metric name, defaults to "activejob.perform"
+    # *<tt>:tags</tt>        - additional tags
+    def initialize(opts = {})
+      super
+      @metric_name = opts[:metric_name] || "activejob.perform"
+
+      Datadog::Notifications.subscribe 'perform.active_job' do |reporter, event|
+        record reporter, event
+      end
+    end
+
+    private
+
+    def record(reporter, event)
+      job  = event.payload[:job]
+      name = job.class.name.sub(/Job$/, '').underscore
+      tags = self.tags + %W|name:#{name} queue:#{job.queue_name}|
+
+      reporter.batch do
+        reporter.increment metric_name, tags: tags
+        reporter.timing "#{metric_name}.time", event.duration, tags: tags
+      end
+    end
+
+  end
+end

data/lib/datadog/notifications/plugins/active_record.rb

@@ -0,0 +1,43 @@
+module Datadog::Notifications::Plugins
+  class ActiveRecord < Base
+
+    attr_reader :metric_name
+
+    # Options:
+    #
+    # *<tt>:metric_name</tt>      - the metric name, defaults to "activerecord.query"
+    # *<tt>:include_schema</tt>   - record schema queries, off by default
+    # *<tt>:include_generic</tt>  - record general (nameless) queries, off by default
+    # *<tt>:tags</tt>             - additional tags
+    def initialize(opts = {})
+      super
+      @metric_name     = opts[:metric_name] || "activerecord.sql"
+      @include_schema  = opts[:include_schema] == true
+      @include_generic = opts[:include_generic] == true
+      @include_raw     = opts[:include_raw] == true
+
+      Datadog::Notifications.subscribe 'sql.active_record' do |reporter, event|
+        record reporter, event
+      end
+    end
+
+    private
+
+    def record(reporter, event)
+      payload = event.payload
+      name    = payload[:name]
+      return if (name.nil? || name == "SQL") && !@include_generic
+      return if name == "SCHEMA" && !@include_schema
+
+      name = name.downcase.split(/\W/).join(".") if name
+      tags = self.tags.dup
+      tags.push "query:#{name}" if name
+
+      reporter.batch do
+        reporter.increment metric_name, tags: tags
+        reporter.timing "#{metric_name}.time", event.duration, tags: tags
+      end
+    end
+
+  end
+end

data/lib/datadog/notifications/plugins/base.rb

@@ -0,0 +1,13 @@
+module Datadog::Notifications::Plugins
+  class Base
+    attr_reader :tags
+
+    # Options:
+    #
+    # *<tt>:tags</tt> - additional tags
+    def initialize(opts = {})
+      @tags = opts[:tags] || []
+    end
+
+  end
+end

data/lib/datadog/notifications/plugins/grape.rb

@@ -0,0 +1,43 @@
+module Datadog::Notifications::Plugins
+  class Grape < Base
+
+    attr_reader :metric_name
+
+    # Options:
+    #
+    # *<tt>:metric_name</tt> - the metric name, defaults to "grape.request"
+    # *<tt>:tags</tt> - additional tags
+    def initialize(opts = {})
+      super
+      @metric_name = opts[:metric_name] || "grape.request"
+
+      Datadog::Notifications.subscribe 'endpoint_run.grape' do |reporter, event|
+        record reporter, event
+      end
+    end
+
+    private
+
+    def record(reporter, event)
+      payload  = event.payload
+      endpoint = payload[:endpoint]
+      route    = endpoint.route
+      version  = route.route_version
+      method   = route.route_method
+
+      path = route.route_path
+      path.sub!("(.:format)", "")
+      path.sub!(":version/", "") if version
+      path.gsub!(/\(?:(\w+)\)?/) {|m| "_#{m[1..-1]}_" }
+
+      tags = self.tags + %W|method:#{method} path:#{path} status:#{endpoint.status}|
+      tags.push "version:#{version}" if version
+
+      reporter.batch do
+        reporter.increment metric_name, tags: tags
+        reporter.timing "#{metric_name}.time", event.duration, tags: tags
+      end
+    end
+
+  end
+end

data/lib/datadog/notifications/reporter.rb

@@ -0,0 +1,6 @@
+module Datadog
+  class Notifications
+    class Reporter < ::Statsd
+    end
+  end
+end

data/lib/datadog/notifications/version.rb

@@ -0,0 +1,5 @@
+module Datadog
+  class Notifications
+    VERSION = "0.3.0"
+  end
+end

data/spec/datadog/notifications/config_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Datadog::Notifications::Config do
+
+  it 'should be connect!' do
+    subject.reporter = Mock::Reporter
+    subject.hostname = "test.host"
+    subject.tags = ["custom:tag"]
+
+    client = subject.send(:connect!)
+    expect(client).to be_instance_of(Mock::Reporter)
+    expect(subject.tags).to eq(["custom:tag", "env:test", "host:test.host"])
+  end
+
+end

data/spec/datadog/notifications/plugins/active_record_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Datadog::Notifications::Plugins::ActiveRecord do
+
+  it 'should send an increment and timing event for each query' do
+    Post.all.to_a
+    expect(buffered).to eq([
+      "activerecord.sql:1|c|#custom:tag,env:test,host:test.host,query:post.load",
+      "activerecord.sql.time:333|ms|#custom:tag,env:test,host:test.host,query:post.load",
+    ])
+  end
+
+  it 'should skip unnamed by default' do
+    Post.create!(title: "Hello!")
+    expect(buffered).to eq([])
+  end
+
+  it 'should support custom queries' do
+    Post.find_by_sql("SELECT * FROM posts LIMIT 1").to_a
+    expect(buffered).to eq([
+      "activerecord.sql:1|c|#custom:tag,env:test,host:test.host,query:post.load",
+      "activerecord.sql.time:333|ms|#custom:tag,env:test,host:test.host,query:post.load",
+    ])
+  end
+
+end

data/spec/datadog/notifications/plugins/grape_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Datadog::Notifications::Plugins::Grape do
+  include Rack::Test::Methods
+
+  let(:app) do
+    sub_api = Class.new(Grape::API) do
+      version 'v1'
+      prefix  'api'
+
+      get('versioned') { "OK" }
+    end
+
+    Class.new(Grape::API) do
+      get 'echo/:key1/:key2' do
+        "#{params['key1']} #{params['key2']}"
+      end
+
+      namespace :sub do
+        mount sub_api
+
+        namespace :secure do
+          get("/resource") { error!("forbidden", 403) }
+        end
+      end
+    end
+  end
+
+  it 'should send an increment and timing event for each request' do
+    get '/echo/1/1234'
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('1 1234')
+
+    expect(buffered).to eq([
+      "api.request:1|c|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/echo/_key1_/_key2_,status:200",
+      "api.request.time:333|ms|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/echo/_key1_/_key2_,status:200",
+    ])
+  end
+
+  it 'should support namespaces and versioning' do
+    get '/api/v1/sub/versioned'
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('OK')
+
+    expect(buffered).to eq([
+      "api.request:1|c|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/api/sub/versioned,status:200,version:v1",
+      "api.request.time:333|ms|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/api/sub/versioned,status:200,version:v1",
+    ])
+  end
+
+  it 'should support deep nesting' do
+    get '/sub/secure/resource'
+    expect(last_response.status).to eq(403)
+    expect(last_response.body).to eq('forbidden')
+
+    expect(buffered).to eq([
+      "api.request:1|c|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/sub/secure/resource,status:403",
+      "api.request.time:333|ms|#custom:tag,env:test,host:test.host,more:tags,method:GET,path:/sub/secure/resource,status:403",
+    ])
+  end
+
+end

data/spec/datadog/notifications_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Datadog::Notifications do
+
+  subject { described_class.instance }
+  after   { ActiveSupport::Notifications.unsubscribe(subscription) }
+
+  let!(:subscription) do
+    subject.subscribe("mock.perform") do |reporter, event|
+      status = event.payload[:status]
+      method = event.payload[:method]
+      tags   = ["status:#{status}", "method:#{method}"]
+
+      reporter.batch do
+        reporter.increment "web.render", tags: tags
+        reporter.timing "web.render.time", event.duration, tags: tags
+      end
+    end
+  end
+
+  it 'should have a reporter' do
+    expect(subject.send(:reporter)).to be_instance_of(Mock::Reporter)
+  end
+
+  it 'should subscribe and report' do
+    Mock::Instrumentable.new(method: 'GET').perform
+    expect(buffered).to eq([
+      "web.render:1|c|#custom:tag,env:test,host:test.host,status:200,method:GET",
+      "web.render.time:333|ms|#custom:tag,env:test,host:test.host,status:200,method:GET",
+    ])
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+ENV['RACK_ENV'] ||= 'test'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'datadog-notifications'
+require 'rspec'
+require 'rack/test'
+require 'grape'
+require 'active_record'
+require 'sqlite3'
+
+### Active-record test preparation
+
+ActiveRecord::Base.configurations["test"] = { 'adapter' => 'sqlite3', 'database' => ':memory:' }
+ActiveRecord::Base.establish_connection(:test)
+ActiveRecord::Base.connection.create_table :posts do |t|
+  t.string :title
+end
+class Post < ActiveRecord::Base
+end
+
+### Mocks
+
+module Mock
+  class Reporter < Datadog::Notifications::Reporter
+    def timing(stat, ms, opts={}); super(stat, 333, opts); end
+    def flush_buffer; end
+    alias :send_stat :send_to_buffer
+  end
+
+  class Instrumentable
+    def initialize(opts = {})
+      @opts = opts
+    end
+
+    def perform
+      ActiveSupport::Notifications.instrument("mock.start", @opts)
+      ActiveSupport::Notifications.instrument("mock.perform", @opts) do |payload|
+        payload[:status] = 200
+      end
+    end
+  end
+end
+
+### Configuration
+
+RSpec.configure do |c|
+  helpers = Module.new do
+    def buffered
+      Datadog::Notifications.instance.send(:reporter).buffer
+    end
+  end
+
+  c.include helpers
+  c.before do
+    buffered.clear
+  end
+end
+
+Datadog::Notifications.configure do |c|
+  c.hostname = "test.host"
+  c.reporter = Mock::Reporter
+  c.tags     = ["custom:tag"]
+
+  c.use Datadog::Notifications::Plugins::ActiveRecord
+  c.use Datadog::Notifications::Plugins::Grape, tags: ["more:tags"], metric_name: "api.request"
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: datadog-notifications
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Dimitrij Denissenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: dogstatsd-ruby
+  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: rack-test
+  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: grape
+  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'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: rake
+  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: bundler
+  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
+  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: Datadog instrumnetation for ActiveSupport::Notifications
+email:
+- dimitrij@blacksquaremedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- MIT-LICENCE
+- README.md
+- Rakefile
+- datadog-notifications.gemspec
+- lib/datadog-notifications.rb
+- lib/datadog/notifications.rb
+- lib/datadog/notifications/config.rb
+- lib/datadog/notifications/plugins.rb
+- lib/datadog/notifications/plugins/action_controller.rb
+- lib/datadog/notifications/plugins/active_job.rb
+- lib/datadog/notifications/plugins/active_record.rb
+- lib/datadog/notifications/plugins/base.rb
+- lib/datadog/notifications/plugins/grape.rb
+- lib/datadog/notifications/reporter.rb
+- lib/datadog/notifications/version.rb
+- spec/datadog/notifications/config_spec.rb
+- spec/datadog/notifications/plugins/active_record_spec.rb
+- spec/datadog/notifications/plugins/grape_spec.rb
+- spec/datadog/notifications_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/datadog-notifications
+licenses: []
+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.4.7
+signing_key: 
+specification_version: 4
+summary: Generic ActiveSupport::Notifications Datadog handler
+test_files:
+- spec/datadog/notifications/config_spec.rb
+- spec/datadog/notifications/plugins/active_record_spec.rb
+- spec/datadog/notifications/plugins/grape_spec.rb
+- spec/datadog/notifications_spec.rb
+- spec/spec_helper.rb