stats_whisper 0.2.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87d40c243254727859766e1abf0e291891a7c967
+  data.tar.gz: 90af9b8d376f74ab09382f6408164c390cc7b44f
+SHA512:
+  metadata.gz: 0603ade301144914f6cc028806715da291c0c2323d260baf900c2eae1dd2eed51e751e6185a2a68e0b4baa0eff1c88a8613dae2332653953046fda8e4a929c0e
+  data.tar.gz: e932f04a9484fbad367e19c7ce0375ac6a811bec72ceead2693f314363cd3b545f984293ac56405188e638cc0209b72dfbb0b97d52f7bc861972487382b4d88b

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+stats.sublime-project
+stats.sublime-workspace

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--require spec_helper
+--order random
+--warnings

data/.ruby-gemset

@@ -0,0 +1 @@
+stats_whisper

data/.ruby-version

@@ -0,0 +1 @@
+2.1

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :tools do
+  platform :mri do
+    gem 'mutant'
+    gem 'mutant-rspec'
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Michal Pietrus
+
+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,84 @@
+# StatsWhisper
+
+Short and simple piece of code to deal with stats gathering. It integrates Rails apps with StatsD and measures two fundamental values:
+
+* Time of request execution (in ms) – each request is distinguished by its path, e.g: `/foo/bar` and `/bar/baz` are considered differently. It uses StatsD [time][1] metric type.
+* Count of visits – a natural number of processed requests for the whole app. Basically it uses StatsD [counter][2] type.
+
+As StatsD is mainly a network daemon to aggregate and send metrics, some another tool is needed for further processing or visualization, e.g. [Graphite][3].
+
+Request paths are translated into Graphite metric pattern, e.g: `/foo/bar` becomes `app_name.foo.bar`. Moreover, for some particular paths replace operation is being done:
+
+* `/en/foo/bar` => `app_name.foo.bar`;
+* `/en` => `app_name.home_page`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stats_whisper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stats_whisper
+
+## Configuration
+
+This library comes with Rails initializer and is ready to use once added to Gemfile app stack. It distinguishes Rails environments and for development environment Rails logger is used. All remaining use StatsD and it is possible to define StatsD location with these environment variables:
+
+* `STATSWHISPER_HOST` – contains hostname where StatsD is listening;
+* `STATSWHISPER_PORT` – contains StatsD port .
+
+You can use here [dotenv][4] gem.
+
+
+### Request paths filtering
+
+By default StatsWhisper listens for any request path and allows all of them to pass. It causes that all request paths are passed to Graphite, which may not be expected bahaviour, because one would be interested only in certain paths, hence it is possible to provide a whitelist to filter "garbage".
+
+Whitelist is an array of regexp patterns provided in config file:
+```
+# Rails.root/config/whisper_config.yml
+
+---
+whitelist:
+  - ^/dashboard
+  - /(pl|en)/main
+```
+
+Then, these patterns are matched against current request path. If path matches, it is passed to StatsD. The whitelist applies only to timers so all requests are counted, even though they don't match.
+
+### Adding app name
+
+To add app name to the metric path, add `app_name` to config file, e.g:
+
+```
+# Rails.root/config/whisper_config.yml
+
+---
+app_name: cool_app
+```
+
+
+## TODO
+
+* Add configurable parser rules, letting the user to define patterns to translate request paths into [Graphite][3] format.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/stats_whisper/fork )
+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. Create a new Pull Request
+
+[1]: https://github.com/etsy/statsd/blob/master/docs/metric_types.md#timing
+[2]: https://github.com/etsy/statsd/blob/master/docs/metric_types.md#counting
+[3]: http://graphite.readthedocs.org/en/latest/overview.html
+[4]: https://github.com/bkeepers/dotenv

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/stats_whisper/backend/logger.rb

@@ -0,0 +1,21 @@
+module StatsWhisper::Backend
+
+  class Logger
+
+    attr_accessor :logger
+
+    def initialize
+      @logger = StatsWhisper.logger
+    end
+
+    def timing(path, timestamp)
+      collect_metric("#{path}:#{timestamp}")
+    end
+
+    def collect_metric(metric)
+      StatsWhisper.logger.info "[StatsWhisper] #{metric}"
+    end
+
+    alias_method :increment, :collect_metric
+  end
+end

data/lib/stats_whisper/backend/statsd.rb

@@ -0,0 +1,23 @@
+require 'statsd-ruby'
+
+module StatsWhisper::Backend
+
+  class StatsD
+
+    extend Forwardable
+
+    def_delegators :@statsd, :increment, :timing
+
+    def initialize
+      @statsd = Statsd.new(hostname, port)
+    end
+
+    def hostname
+      ENV['STATSWHISPER_HOST'] || 'localhost'
+    end
+
+    def port
+      ENV['STATSWHISPER_PORT'] || 8125
+    end
+  end
+end

data/lib/stats_whisper/caller.rb

@@ -0,0 +1,31 @@
+require_relative "environment"
+require_relative "parser"
+require_relative "config"
+
+module StatsWhisper
+
+  module Caller
+
+    include Parser
+    include Config
+
+    def gather_stats(env, response_time)
+
+      if timing_allowed?(env["REQUEST_PATH"])
+        StatsWhisper.backend.timing(build_key(app_name, 'http', env["REQUEST_METHOD"],
+                                              parse(env["REQUEST_PATH"]),
+                                              'response_time'),
+                                    response_time)
+      end
+      StatsWhisper.backend.increment(build_key(app_name, 'http', 'visits'))
+    end
+
+    def timing_allowed?(request_path)
+      whitelist.empty? || whitelist.any? do |pattern|
+        Regexp.new(pattern) =~ request_path
+      end
+
+    end
+
+  end
+end

data/lib/stats_whisper/config.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module StatsWhisper
+  module Config
+
+    def config
+      @config ||= load_config
+    end
+
+    def whitelist
+      config['whitelist'] || []
+    end
+
+    def app_name
+      config['app_name'] || 'foo'
+    end
+
+    private
+
+    def load_config
+      begin
+        YAML.load(ERB.new(File.new(Rails.root.join("config", "whisper_config.yml")).read).result)
+      rescue Errno::ENOENT
+        {}
+      end
+    end
+
+  end
+end

data/lib/stats_whisper/environment.rb

@@ -0,0 +1,30 @@
+require_relative 'config'
+
+require_relative 'backend/logger'
+require_relative 'backend/statsd'
+
+
+module StatsWhisper
+  module Environment
+
+    extend self
+
+    def backend
+      case environment
+      when 'production', 'staging', 'test'
+        Backend::StatsD.new
+      else
+        Backend::Logger.new
+      end
+    end
+
+    def environment
+      if defined?(Rails)
+        Rails.env
+      else
+        ENV['RAILS_ENV'] || 'development'
+      end
+    end
+
+  end
+end

data/lib/stats_whisper/middleware.rb

@@ -0,0 +1,24 @@
+require_relative 'caller'
+
+module StatsWhisper
+  class Middleware
+
+    include Caller
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      (status, headers, body), response_time = call_with_timing(env)
+      gather_stats(env, response_time)
+      [status, headers, body]
+    end
+
+    def call_with_timing(env)
+      start = Time.now
+      result = @app.call(env)
+      [result, ((Time.now - start) * 1000).round]
+    end
+  end
+end

data/lib/stats_whisper/parser.rb

@@ -0,0 +1,17 @@
+module StatsWhisper::Parser
+
+  def parse(path)
+    path = path.gsub(/\/(pl|en|(\d){4}\-(\d){4})/) do
+      if $'.empty?
+        '/'
+      end
+    end
+    path.slice!(0) if path =~ /\/.+/
+    path.sub(/^\/$/, "home_page").gsub('/', '.')
+  end
+
+  def build_key(*args)
+    args.join(".")
+  end
+
+end

data/lib/stats_whisper/railtie.rb

@@ -0,0 +1,14 @@
+require "stats_whisper/middleware"
+
+module StatsWhisper
+  class Railtie < Rails::Railtie
+
+    initializer 'statsd-instrument.use_rails_logger' do
+      ::StatsWhisper.logger = Rails.logger
+    end
+
+    initializer "stats_whisper.insert_middleware" do |app|
+      app.config.middleware.use "StatsWhisper::Middleware"
+    end
+  end
+end

data/lib/stats_whisper/version.rb

@@ -0,0 +1,3 @@
+module StatsWhisper
+  VERSION = "0.2.2.1"
+end

data/lib/stats_whisper.rb

@@ -0,0 +1,18 @@
+require "stats_whisper/version"
+require 'logger'
+
+
+require 'stats_whisper/railtie' if defined?(Rails)
+
+module StatsWhisper
+  extend self
+
+  attr_accessor :logger
+  attr_writer :backend
+
+  def backend
+    @backend ||= StatsWhisper::Environment.backend
+  end
+end
+
+StatsWhisper.logger = Logger.new($stderr)

data/spec/fixtures/config/whisper_config.yml

@@ -0,0 +1,7 @@
+---
+
+app_name: bar
+
+whitelist:
+  - ^/dashboard
+  - /en/main

data/spec/integration/caller_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'stats_whisper/caller'
+require_relative 'statsd_helper'
+
+describe StatsWhisper::Caller do
+  subject { Class.new { extend StatsWhisper::Caller } }
+
+  before do
+    Rails = double(:root => Pathname.new("spec/fixtures"))
+  end
+
+  after do
+    Object.send(:remove_const, :Rails)
+  end
+
+  describe "#gather_stats" do
+    before do
+      allow(Rails).to receive(:env).and_return("production")
+
+      StatsWhisper.backend = StatsD.new
+
+    end
+
+    it "adds timing stats" do
+      subject.gather_stats({'REQUEST_PATH' => '/en/main',
+                            'REQUEST_METHOD' => 'GET'}, 234)
+      expect(StatsWhisper.backend.timing_key).to eq('bar.http.GET.main.response_time')
+      expect(StatsWhisper.backend.increment_key).to eq('bar.http.visits')
+
+    end
+
+  end
+
+  describe "#timing_allowed?" do
+
+    context "when whitelist is given" do
+      it "allows only certain paths" do
+        expect(subject.timing_allowed?("/en/main")).to eq(true)
+      end
+    end
+  end
+end

data/spec/integration/config_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'stats_whisper/config'
+
+describe StatsWhisper::Config do
+  subject { Class.new { extend StatsWhisper::Config } }
+
+  before do
+    Rails = double(:root => Pathname.new("spec/fixtures"))
+  end
+
+  after do
+    Object.send(:remove_const, :Rails)
+  end
+
+  describe "#app_name" do
+
+    context "when config file is given" do
+      it "returns specified app name" do
+        expect(subject.app_name).to eq('bar')
+      end
+    end
+  end
+end

data/spec/integration/statsd_helper.rb

@@ -0,0 +1,8 @@
+StatsD = Class.new do
+  def initalize(hostname, port); @increment = 0; end
+  def timing(key, time); @timing = key; end
+  def increment(key); @increment = key; end
+
+  def timing_key; @timing; end
+  def increment_key; @increment; end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'stats_whisper'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/unit/caller_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'stats_whisper/caller'
+
+describe StatsWhisper::Caller do
+  let(:ctxt) { Class.new { extend StatsWhisper::Caller } }
+
+  describe "#timing_allowed?" do
+
+    context "when whitelist is empty" do
+      it "allows to receive any path" do
+        allow(ctxt).to receive(:whitelist).and_return([])
+        expect(ctxt.timing_allowed?("/bleh/blah/ok")).to eq(true)
+      end
+    end
+
+    context "when whitelist is not empty" do
+      before do
+        allow(ctxt).to receive(:whitelist).and_return(["/home.*"])
+      end
+
+      it "allows only certain paths" do
+        expect(ctxt.timing_allowed?("/home/page")).to eq(true)
+      end
+
+      it "rejects not allowed paths" do
+        expect(ctxt.timing_allowed?("/dashboard")).to eq(false)
+      end
+    end
+
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'stats_whisper/config'
+
+describe StatsWhisper::Config do
+  let(:ctxt) { Class.new { extend StatsWhisper::Config } }
+
+  describe "#whitelist" do
+
+    context "when whitelist in config is empty" do
+      before do
+        allow(ctxt).to receive(:config).and_return({})
+      end
+
+      it "returns an empty array" do
+        expect(ctxt.whitelist).to eq([])
+      end
+    end
+
+    context "when whitelist in config is not empty" do
+      before do
+        allow(ctxt).to receive(:config).and_return({'whitelist' => ['ok!']})
+      end
+
+      it "returns non-empty array" do
+        expect(ctxt.whitelist).not_to be_empty
+      end
+    end
+  end
+
+  describe "#app_name" do
+    context "when app_name in config is empty" do
+      before do
+        allow(ctxt).to receive(:config).and_return({})
+      end
+
+      it "returns default value" do
+        expect(ctxt.app_name).to eq('foo')
+
+      end
+    end
+
+    context "when env variable is undefined" do
+      before do
+        allow(ctxt).to receive(:config).and_return({'app_name' => "cool_app"})
+      end
+
+      it "returns provided app name" do
+        expect(ctxt.app_name).to eq('cool_app')
+      end
+    end
+  end
+
+  describe "#config" do
+    before do
+      Rails = double(:root => Pathname.new(fixtures_path))
+    end
+
+    after do
+      Object.send(:remove_const, :Rails)
+    end
+
+    context "when config file is not present" do
+      let(:fixtures_path) { "spec/non_existing_fixtures" }
+
+
+      it "returns empty hash" do
+        expect(ctxt.config).to eq({})
+      end
+    end
+
+    context "when config file is present" do
+      let(:fixtures_path) { "spec/fixtures" }
+
+
+      it "returns non empty hash" do
+        expect(ctxt.config).not_to be_empty
+      end
+    end
+  end
+end

data/spec/unit/environment_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'stats_whisper/environment'
+
+describe StatsWhisper::Environment do
+  let(:ctxt) { Class.new { extend StatsWhisper::Environment } }
+
+
+  describe "#backend" do
+
+    %w(production staging test).each do |env|
+      context "when environment is #{env}" do
+        before do
+          allow(ctxt).to receive(:environment).and_return(env)
+        end
+
+        it 'returns statsd backend' do
+          expect(ctxt.backend).to be_kind_of(StatsWhisper::Backend::StatsD)
+        end
+      end
+    end
+
+    context "when environment is some_cool_env" do
+      before do
+        allow(ctxt).to receive(:environment).and_return('some_cool_env')
+      end
+
+      it 'returns logger backend' do
+        expect(ctxt.backend).to be_kind_of(StatsWhisper::Backend::Logger)
+      end
+    end
+  end
+
+  describe "#environment" do
+
+    context 'when Rails defined' do
+      before do
+        Rails = double(:env => 'test')
+      end
+
+      after do
+        Object.send(:remove_const, :Rails)
+      end
+
+      it "reads env from Rails" do
+        expect(ctxt.environment).to eq('test')
+      end
+    end
+
+    context 'when Rails undefined' do
+
+      it "reads env from ENV" do
+        allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("test")
+        expect(ctxt.environment).to eq('test')
+      end
+
+      it "sets development if ENV is empty" do
+        expect(ctxt.environment).to eq('development')
+      end
+    end
+  end
+end

data/spec/unit/parser_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'stats_whisper/parser'
+
+describe StatsWhisper::Parser do
+  let(:ctxt) { Class.new { extend StatsWhisper::Parser } }
+
+  describe "#parse" do
+
+
+    context "when req path is empty" do
+      it "resolves base uri" do
+        path = "/"
+        expect(ctxt.parse(path)).to eq("home_page")
+      end
+    end
+
+    context "when req path is root path" do
+      it "resolves root path" do
+        path = "/en"
+        expect(ctxt.parse(path)).to eq("home_page")
+      end
+    end
+
+    context "when req path points to a resource" do
+      it "resolves resource path" do
+        path = "/en/dashboard"
+        expect(ctxt.parse(path)).to eq("dashboard")
+
+        path = "/2015-2016/pl/treasuries/academy_units/offer"
+        expect(ctxt.parse(path)).to eq("treasuries.academy_units.offer")
+      end
+    end
+  end
+
+  describe "#build_key" do
+    it "generates valid Graphite key" do
+      expect(ctxt.build_key("bleh", 'blah', "dash")).to eq("bleh.blah.dash")
+    end
+  end
+end

data/stats_whisper.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stats_whisper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stats_whisper"
+  spec.version       = StatsWhisper::VERSION
+  spec.authors       = ["Michal Pietrus"]
+  spec.email         = ["blelump@martex.nom.pl"]
+  spec.summary       = %q{A simple middleware to gather metrics and interact with StatsD.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/Opensoftware/stats_whisper"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", " ~> 3.3"
+
+  spec.add_dependency "statsd-ruby", "~> 1.2"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: stats_whisper
+version: !ruby/object:Gem::Version
+  version: 0.2.2.1
+platform: ruby
+authors:
+- Michal Pietrus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: statsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A simple middleware to gather metrics and interact with StatsD.
+email:
+- blelump@martex.nom.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/stats_whisper.rb
+- lib/stats_whisper/backend/logger.rb
+- lib/stats_whisper/backend/statsd.rb
+- lib/stats_whisper/caller.rb
+- lib/stats_whisper/config.rb
+- lib/stats_whisper/environment.rb
+- lib/stats_whisper/middleware.rb
+- lib/stats_whisper/parser.rb
+- lib/stats_whisper/railtie.rb
+- lib/stats_whisper/version.rb
+- spec/fixtures/config/whisper_config.yml
+- spec/integration/caller_spec.rb
+- spec/integration/config_spec.rb
+- spec/integration/statsd_helper.rb
+- spec/spec_helper.rb
+- spec/unit/caller_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/environment_spec.rb
+- spec/unit/parser_spec.rb
+- stats_whisper.gemspec
+homepage: https://github.com/Opensoftware/stats_whisper
+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.4.3
+signing_key: 
+specification_version: 4
+summary: A simple middleware to gather metrics and interact with StatsD.
+test_files:
+- spec/fixtures/config/whisper_config.yml
+- spec/integration/caller_spec.rb
+- spec/integration/config_spec.rb
+- spec/integration/statsd_helper.rb
+- spec/spec_helper.rb
+- spec/unit/caller_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/environment_spec.rb
+- spec/unit/parser_spec.rb