macmillan-utils 1.0.11

data/lib/macmillan/utils/statsd_middleware.rb

@@ -0,0 +1,87 @@
+require 'set'
+
+module Macmillan
+  module Utils
+    ##
+    # Rack Middleware for sending request timings and other statistics to StatsD.
+    #
+    # This code is heavily inspired by https://github.com/manderson26/statsd/blob/master/lib/statsd/middleware.rb
+    #
+    # == Usage:
+    #
+    # In config.ru:
+    #
+    #   require 'statsd'
+    #   require 'macmillan/utils/statsd_decorator'
+    #   require 'macmillan/utils/statsd_middleware'
+    #
+    #   statsd = Statsd.new('http://statsd.example.com', 8080)
+    #   statsd = Macmillan::Utils::StatsdDecorator.new(statsd, ENV['RACK_ENV'])
+    #
+    #   use Macmillan::Utils::StatsdMiddleware, client: statsd
+    #
+    # By default this middleware will record timer and increment stats for all requests under
+    # the statsd/graphite namespace 'rack.' - i.e.
+    #
+    # * rack.request - timers and increment per request
+    # * rack.status_code.<status code> - increment per request
+    # * rack.exception - increment upon error
+    #
+    # Facilities are provided via {Macmillan::Utils::StatsdControllerHelper} to also log
+    # per-route metrics via this middleware.
+    #
+    class StatsdMiddleware
+      NAMESPACE  = 'rack'.freeze
+      TIMERS     = 'statsd.timers'.freeze
+      INCREMENTS = 'statsd.increments'.freeze
+
+      def initialize(app, opts = {})
+        fail ArgumentError, 'You must supply a StatsD client' unless opts[:client]
+
+        @app    = app
+        @client = opts[:client]
+      end
+
+      def call(env)
+        dup.process(env)
+      end
+
+      def process(env)
+        setup(env)
+
+        (status, headers, body), response_time = call_with_timing(env)
+
+        record_metrics(env, status, response_time)
+
+        [status, headers, body]
+      rescue => error
+        @client.increment("#{NAMESPACE}.exception")
+        raise error
+      end
+
+      private
+
+      def setup(env)
+        env[TIMERS]     = Set.new(['request'])
+        env[INCREMENTS] = Set.new(['request'])
+      end
+
+      def record_metrics(env, status, response_time)
+        env[TIMERS].each do |key|
+          @client.timing("#{NAMESPACE}.timers.#{key}", response_time)
+        end
+
+        env[INCREMENTS].each do |key|
+          @client.increment("#{NAMESPACE}.increments.#{key}")
+          @client.increment("#{NAMESPACE}.http_status.#{key}.#{status}")
+        end
+      end
+
+      def call_with_timing(env)
+        start  = Time.now
+        result = @app.call(env)
+        [result, ((Time.now - start) * 1000).round]
+      end
+    end
+  end
+end

data/lib/macmillan/utils/statsd_stub.rb

@@ -0,0 +1,43 @@
+module Macmillan
+  module Utils
+    ##
+    # A test helper class for stubbing out interaction with StatsD.
+    #
+    # === Usage (in spec/spec_helper.rb):
+    #
+    #   require 'macmillan/utils/statsd_stub'
+    #
+    #   RSpec.configure do |config|
+    #     config.before(:suite) do
+    #       $statsd = Macmillan::Utils::StatsdStub.new
+    #     end
+    #   end
+    #
+    # @see Macmillan::Utils::StatsdDecorator
+    # @see http://rubygems.org/gems/statsd-ruby
+    #
+    class StatsdStub
+      def increment(_stat, _sample_rate = 1)
+      end
+
+      def decrement(_stat, _sample_rate = 1)
+      end
+
+      def count(_stat, _count, _sample_rate = 1)
+      end
+
+      def guage(_stat, _value, _sample_rate = 1)
+      end
+
+      def set(_stat, _value, _sample_rate = 1)
+      end
+
+      def timing(_stat, _ms, _sample_rate = 1)
+      end
+
+      def time(_stat, _sample_rate = 1)
+        yield
+      end
+    end
+  end
+end

data/lib/macmillan/utils/test_helpers/codeclimate_helper.rb

@@ -0,0 +1,4 @@
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end

data/lib/macmillan/utils/test_helpers/fixture_loading_helper.rb

@@ -0,0 +1,24 @@
+module FixtureLoading
+  # ASSUMPTION: We are running the test suite from the root of a project tree
+
+  def load_yaml_data(filename)
+    filename << '.yml' unless filename.end_with?('.yml')
+    YAML.load(load_text_data(filename))
+  end
+
+  def load_json_data(filename)
+    filename << '.json' unless filename.end_with?('.json')
+    JSON.parse(load_text_data(filename))
+  end
+
+  def load_text_data(filename)
+    File.open(get_file_name(filename), 'rb').read
+  end
+
+  private
+
+  def get_file_name(filename)
+    File.join(Dir.getwd, 'spec/support/fixtures', filename)
+  end
+end
+include FixtureLoading

data/lib/macmillan/utils/test_helpers/simplecov_helper.rb

@@ -0,0 +1,27 @@
+if ENV['USE_SIMPLECOV']
+  require 'simplecov'
+  require 'simplecov-rcov'
+
+  formatters = [
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::RcovFormatter
+  ]
+
+  if ENV['CODECLIMATE_REPO_TOKEN']
+    require 'codeclimate-test-reporter'
+    formatters << CodeClimate::TestReporter::Formatter
+  end
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+
+  unless ENV['DO_NOT_START_SIMPLECOV']
+    mode = nil
+    mode = 'rails' if ENV['RAILS_ENV']
+
+    SimpleCov.start mode do
+      load_profile 'test_frameworks'
+      merge_timeout 3600
+      coverage_dir 'artifacts/coverage'
+    end
+  end
+end

data/macmillan-utils.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'macmillan-utils'
+  spec.version       = "1.0.#{ENV['BUILD_NUMBER'] || 'dev'}"
+  spec.authors       = ['Macmillan Science and Education (New Publsihing Platforms)']
+  spec.email         = ['npp-developers@macmillan.com']
+  spec.summary       = 'A collection of useful patterns we (Macmillan Science and Education) use in our Ruby applications.'
+  spec.homepage      = 'https://github.com/nature/macmillan-utils'
+  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.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rack-test'
+
+  spec.add_dependency 'rspec'
+  spec.add_dependency 'simplecov'
+  spec.add_dependency 'simplecov-rcov'
+  spec.add_dependency 'codeclimate-test-reporter'
+  spec.add_dependency 'webmock'
+  spec.add_dependency 'multi_test'
+  spec.add_dependency 'syslog-logger'
+  spec.add_dependency 'rubocop'
+  spec.add_dependency 'geminabox'
+end

data/spec/fixtures/config/application.yml

@@ -0,0 +1 @@
+process_pid: 1234

data/spec/lib/macmillan/utils/logger/factory_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Macmillan::Utils::Logger::Factory do
+  describe '#build_logger' do
+    context 'for a syslog logger' do
+      subject { Macmillan::Utils::Logger::Factory.build_logger(:syslog, tag: 'myapp', facility: 2) }
+
+      it 'returns a Logger::Syslog object' do
+        expect(subject).to be_an_instance_of(Logger::Syslog)
+      end
+
+      it 'allows you to configure the syslog tag and facility' do
+        expect(Logger::Syslog).to receive(:new).with('myapp', Syslog::LOG_LOCAL2).and_call_original
+        subject
+      end
+
+      it 'aliases logger#write to logger#info' do
+        expect(subject).to respond_to(:write)
+      end
+    end
+
+    context 'for a standard Logger' do
+      subject { Macmillan::Utils::Logger::Factory.build_logger(:logger) }
+
+      it 'returns a Logger object' do
+        expect(subject).to be_an_instance_of(Logger)
+      end
+
+      it 'logs to STDOUT by default' do
+        expect(Logger).to receive(:new).with($stdout).and_call_original
+        subject
+      end
+
+      it 'allows you to configure the log target' do
+        expect(Logger).to receive(:new).with('foo.log').and_call_original
+        Macmillan::Utils::Logger::Factory.build_logger(:logger, target: 'foo.log')
+      end
+    end
+
+    context 'for a null logger' do
+      subject { Macmillan::Utils::Logger::Factory.build_logger(:null) }
+
+      it 'returns a Logger object' do
+        expect(subject).to be_an_instance_of(Logger)
+      end
+
+      it 'builds a logger object that points to /dev/null' do
+        expect(Logger).to receive(:new).with('/dev/null').and_call_original
+        subject
+      end
+    end
+  end
+end

data/spec/lib/macmillan/utils/logger/formatter_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Macmillan::Utils::Logger::Formatter do
+  let(:msg)    { 'testing' }
+  let(:prefix) { nil }
+  let(:target) { File.open('/dev/null', 'w+') }
+
+  subject { Macmillan::Utils::Logger::Formatter.new(prefix) }
+
+  let(:logger) do
+    log = Macmillan::Utils::Logger::Factory.build_logger(:logger, target: target)
+    log.formatter = subject
+    log
+  end
+
+  describe '#call' do
+    it 'is called by the logger object' do
+      expect(target).to receive(:write).once
+      expect(subject).to receive(:call).once
+      logger.info 'this is a test'
+    end
+
+    context 'when a prefix is set' do
+      let(:prefix) { 'WEEEE' }
+
+      it 'is put in front of the log message' do
+        expect(target).to receive(:write).with("#{prefix} [ INFO]: #{msg}\n").once
+        logger.info msg
+      end
+    end
+
+    context 'when the log message is a string' do
+      it 'returns the string' do
+        expect(target).to receive(:write).with("[ INFO]: #{msg}\n").once
+        logger.info msg
+      end
+    end
+
+    context 'when the log message is an exception' do
+      it 'returns full details of the exception' do
+        ex = StandardError.new('qwerty')
+        allow(ex).to receive(:backtrace).and_return(%w(foo bar baz quux))
+        expect(target).to receive(:write).with("[ INFO]: qwerty (StandardError)\nfoo\nbar\nbaz\nquux\n").once
+        logger.info ex
+      end
+    end
+
+    context 'when the log message is NOT a string or exception' do
+      it 'retuns object.inspect' do
+        ex = Array.new
+        expect(ex).to receive(:inspect).once
+
+        logger.info ex
+      end
+    end
+  end
+end

data/spec/lib/macmillan/utils/middleware/weak_etags_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Macmillan::Utils::Middleware::WeakEtags do
+  let(:etag)  { 'W/"qwerty"' }
+  let(:app)   { ->(env) { [200, env, 'app'] } }
+
+  let(:request) do
+    req = req_for('http://example.com')
+    req.env['HTTP_IF_NONE_MATCH'] = etag
+    req
+  end
+
+  subject { Macmillan::Utils::Middleware::WeakEtags.new(app) }
+
+  context 'when using Weak ETags' do
+    it 'removes the "W/" from the header' do
+      _status, headers, _body = subject.call(request.env)
+      expect(headers['HTTP_IF_NONE_MATCH']).to eq('"qwerty"')
+    end
+  end
+
+  context 'when using Strong ETags' do
+    let(:etag) { '"qwerty"' }
+
+    it 'does not modify the header' do
+      _status, headers, _body = subject.call(request.env)
+      expect(headers['HTTP_IF_NONE_MATCH']).to eq('"qwerty"')
+    end
+  end
+end

data/spec/lib/macmillan/utils/settings_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Macmillan::Utils::Settings do
+  let(:env_vars_backend) { Macmillan::Utils::Settings::EnvVarsBackend.new }
+  let(:app_yaml_backend) { Macmillan::Utils::Settings::AppYamlBackend.new }
+  let(:backends)         { [env_vars_backend, app_yaml_backend] }
+
+  subject { Macmillan::Utils::Settings::Lookup.new(backends) }
+
+  it 'lookups variables from the local environment' do
+    ENV['FOO'] = 'bar'
+    var = subject.lookup 'foo'
+    expect(var).to eql 'bar'
+  end
+
+  it 'raises an error if the lookup fails' do
+    looker_upper = Macmillan::Utils::Settings::Lookup.new([env_vars_backend])
+
+    expect do
+      looker_upper.lookup 'baz'
+    end.to raise_error(Macmillan::Utils::Settings::KeyNotFoundError)
+  end
+
+  context 'when using an application.yml file' do
+    context 'and the file exists' do
+      it 'lookups variables from the local application yml' do
+        fixtures_dir = File.expand_path('../../../../fixtures', __FILE__)
+
+        Dir.chdir(fixtures_dir) do
+          var = subject.lookup 'process_pid'
+          expect(var).to eql(1234)
+        end
+      end
+    end
+
+    context 'but the file does not exist' do
+      it 'raises an appropriate error' do
+        expect do
+          subject.lookup 'wibble'
+        end.to raise_error('cannot find application.yml')
+      end
+    end
+  end
+end

data/spec/lib/macmillan/utils/statsd_controller_helper_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Macmillan::Utils::StatsdControllerHelper do
+  let(:request)    { req_for('http://example.com') }
+  let(:timers)     { [] }
+  let(:increments) { [] }
+
+  class TestSubject
+    attr_accessor :request
+
+    include Macmillan::Utils::StatsdControllerHelper
+  end
+
+  subject { TestSubject.new }
+
+  before do
+    subject.request = request
+    request.env[::Macmillan::Utils::StatsdMiddleware::TIMERS] = timers
+    request.env[::Macmillan::Utils::StatsdMiddleware::INCREMENTS] = increments
+  end
+
+  describe '#add_statsd_timer' do
+    it 'adds a key to the correct env variable' do
+      subject.send(:add_statsd_timer, 'woo')
+      expect(request.env[::Macmillan::Utils::StatsdMiddleware::TIMERS]).to eq(['woo'])
+    end
+  end
+
+  describe '#add_statsd_increment' do
+    it 'adds a key to the correct env variable' do
+      subject.send(:add_statsd_increment, 'waa')
+      expect(request.env[::Macmillan::Utils::StatsdMiddleware::INCREMENTS]).to eq(['waa'])
+    end
+  end
+
+  describe '#add_statsd_timer_and_increment' do
+    it 'adds a key to both env variables' do
+      subject.send(:add_statsd_timer_and_increment, 'wee')
+      expect(request.env[::Macmillan::Utils::StatsdMiddleware::TIMERS]).to eq(['wee'])
+      expect(request.env[::Macmillan::Utils::StatsdMiddleware::INCREMENTS]).to eq(['wee'])
+    end
+  end
+end