squash_repeater 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 219ecac4dc1a24819c44deee687c56d0cadbe2b2
+  data.tar.gz: cf636f9dd0f10862986aa4f09041fd16705f6f19
+SHA512:
+  metadata.gz: c93756e6d025867532c462cc38fb74c46584ffca9ea47cba2f113697e2ab39d520fc0729dc503990fa94affe0c41b1b90cab4099509f26c487150b74ab0811df
+  data.tar.gz: cef8c48c93aea8e1e1136eb93854aff7a790e8717b2bb5ad508828be3720bb749d3e42a8937bd066724a799bf6181485c4ed57eeebfbf0262fe8866bf61c8ef5

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in squash_repeater-ruby.gemspec
+gemspec
+
+# Latest beaneater has an important fix (see https://github.com/powershop/squash_repeater/issues/2):
+# You may need to add this to your including library until a new gem of beaneater is released:
+#gem 'beaneater', :github => 'beanstalkd/beaneater'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Powershop
+
+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,128 @@
+# SquashRepeater
+
+One difficulty with Squash is that whenever any exception occurs, it contacts the
+Squash server to upload details of that failure, which means the code blocks until
+contact is made or the connection times-out.
+
+In many cases, an exception is a failure, and you probably don't want to be nice
+about it, but for user-facing app's, you're degrading the user-experience even
+further.  A quick-response "failure" message to the user is still many times better
+than waiting many seconds (or more).
+
+On top of that, almost all exceptions are valuable, in that they have captured a
+failure-mode that you weren't previously aware of.  If the server is down, then the
+chances are that data is lost.
+
+Squash Repeater uses a low-overhead queueing service to capture any exceptions and
+return control as quickly as possible, after which an independent "worker" process
+will attempt to send the queued exception reports to the Squash server.
+This should mean:
+- the local Squash client code can return far more quickly
+- any exception reports that fail to be accepted by the Squash server aren't lost
+  (or dropped from the queue)
+- we can "distribute" part of the Squash service throughout all the client servers
+
+It doesn't solve things like
+- multi-homed / distributed Squash server
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'squash_repeater', github: 'powershop/squash_repeater'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install squash_repeater
+
+If you're using Rails, you can install an initialiser template with:
+
+    $ bundle exec rails generate squash_repeater:install
+
+## Install `beanstalkd`
+
+- Configure it to listen on `localhost` network
+- Configure it to auto-start on system boot
+- Give it a persistent store for queue data (needed in-order to not lose data)
+
+## Configure `backburner`
+
+`backburner` is the Gem used to interact with the `beanstalk` queue.
+It works in two parts:  client libraries that put data on the queue, and background-worker jobs that process the data on
+queue.
+
+Simply adding the Gem to your app will configure the client part with useful defaults.
+
+To enable the background-worker part, you need to be able to automatically start the `backburner` worker.
+The `backburner` Gem documentation covers this is detail, but they include a God script.
+
+I've included a set of example Ubuntu Upstart scripts in the `share/upstart` directory, which you will need to update
+with details like "app_name" and "app_dir" and install to your machine's `/etc/init/` dir.
+You may also need to make other adjustments to it according to your needs and/or skill.
+
+Alternatively, you can either start `backburner` in daemon mode with:
+
+    $ cd ${app_dir}
+    $ bundle exec backburner -d -r ${app_config}
+
+Or wrapped with some-other daemoniser (such as Niet) with:
+
+    $ niet -t backburner -c ${app_dir} -- bundle exec backburner -r ${app_config}
+
+NB: Replace ${app_dir} with the directory your app is installed to, and ${app_config} with the path to your Squash
+Repeater config.
+
+## Configure Squash Repeater
+
+You need to `require "squash_repeater"` and then use `SquashRepeater.configure` to configure it, e.g:
+
+```ruby
+require "squash_repeater"
+
+SquashRepeater.configure do |c|
+  # The nature of SquashRepeater is that a tiny local queueing system
+  # captures the Squash notification, and retransmits it from a worker.
+  # Therefore, we assume beanstalkd is running locally:
+
+  ###
+  # Backburner defaults:
+  #c.backburner.beanstalk_url = "beanstalk://localhost"
+  #c.backburner.tube_namespace = "squash-repeater"
+  #c.backburner.max_job_retries = 10   # retry jobs 10 times
+  #c.backburner.retry_delay = 30   # wait 30 seconds in between retries
+
+
+  ###
+  # You can set Squash::Ruby config here, or through their configration method. Either way, they must be set:
+  # @param api_host:
+  #c.squash.api_host = "http://no.where"
+  # @param api_key:
+  #c.squash.api_key = "12345"
+  # @param environment:
+  c.squash.environment = Rails.env if defined? Rails.env
+  # @param disabled:
+  #c.squash.disabled = !c.squash_key
+
+  ###
+  # This sets the SquashRepeater and Backburner logging.
+  # There's no easy way to set Squash to use Logger:
+  c.logger = Rails.logger if defined? Rails.logger
+end
+```
+
+As mentioned above, you can configure a few `Squash::Ruby` settings via this config block, or configure it in the Squash
+way via `Squash::Ruby.configure()`
+
+## Contributing
+
+1. Fork it ( https://github.com/powershop/squash_repeater/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

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.rspec_opts = ["--color"]
+    # task.rspec_opts = ["--color", "--format", "nested"]
+  end
+rescue LoadError
+end
+
+task :default => :spec

data/lib/generators/squash_repeater/install_generator.rb

@@ -0,0 +1,16 @@
+require "rails/generators"
+
+module SquashRepeater
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+      desc "Creates SquashRepeater initializer for your application"
+
+      def copy_initializer
+        template "squash_repeater_initializer.rb", "config/initializers/squash_repeater.rb"
+
+        puts "Install complete! Truly Outrageous!"
+      end
+    end
+  end
+end

data/lib/generators/templates/squash_repeater_initializer.rb

@@ -0,0 +1,30 @@
+require "squash_repeater"
+
+SquashRepeater.configure do |c|
+  # The nature of SquashRepeater is that a tiny local queueing system
+  # captures the Squash notification, and retransmits it from a worker.
+  # Therefore, we assume beanstalkd is running locally:
+
+  ###
+  # Backburner defaults:
+  #c.backburner.beanstalk_url = "beanstalk://localhost"
+  #c.backburner.tube_namespace = "squash-repeater"
+  #c.backburner.max_job_retries = 10   # retry jobs 10 times
+  #c.backburner.retry_delay = 30   # wait 30 seconds in between retries
+
+  ###
+  # You can set Squash::Ruby config here, or through their configration method. Either way, they must be set:
+  # @param api_host:
+  #c.squash.api_host = "http://no.where"
+  # @param api_key:
+  #c.squash.api_key = "12345"
+  # @param environment:
+  c.squash.environment = Rails.env if defined? Rails.env
+  # @param disabled:
+  #c.squash.disabled = !c.squash_key
+
+  ###
+  # This sets the SquashRepeater and Backburner logging.
+  # There's no easy way to set Squash to use Logger:
+  c.logger = Rails.logger if defined? Rails.logger
+end

data/lib/squash_repeater/configure/squash.rb

@@ -0,0 +1,37 @@
+# Wrap Squash::Ruby's slightly nasty configuration method with
+# a config-block class
+#
+# Squash accepts configuration via a key-value hash passed to the #configure class method
+# and provides reading that configuration by passing a key the #configuration class method and returning the
+# value for that key/attribute.
+# This class attempts to emulate a tradtional Configure-block class (a la Struct / OpenStruct) but calls-into
+# Squash's configuration methods;  this helps make the rest of the SquashRepeater Configure class simpler.
+# This class is probably more-like OpenStruct in-use, as it doesn't do any checking of "allowed" attributes, which
+# is more-similar to how Squash treats configuration attr's.
+# I didn't bother implementing all the methods you might expect, as this should really only be consumed by
+# SquashRepeater users, at a fairly simplistic level.
+
+class SquashRepeater::Configuration::Squash
+  def self.configure
+    self.configuration  # Initialise
+    yield configuration if block_given?
+  end
+
+  def self.configuration
+    @configuration ||= self.new
+    #return @configuration
+  end
+
+  def method_missing(method_sym, val=nil)
+    fail "Can't extract a meaningful name from the provided method_sym" unless method_sym.to_s =~ /^(.+?)=?$/
+    key = $1.to_sym
+
+    if method_sym.to_s =~ /=$/
+      # Setter
+      Squash::Ruby.configure({ key => val })
+    end
+    # Getter
+    #NB: Always return the value for the key
+    Squash::Ruby.configuration(key)
+  end
+end

data/lib/squash_repeater/configure.rb

@@ -0,0 +1,76 @@
+require "backburner"
+require "squash/ruby"
+
+module SquashRepeater
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new  # Initialise
+    yield configuration if block_given?
+  end
+
+  class Configuration
+    attr_reader :logger
+    attr_accessor :capture_timeout
+
+    def initialize
+      #NB: You definitely want to think about changing this to something more "substantial"; beanstalkd goes down, you'll lose data.
+      self.logger = Logger.new(STDERR)
+      self.capture_timeout = 2  # seconds
+
+      backburner do |c|
+        # The nature of SquashRepeater is that a tiny local queueing system
+        # captures the Squash notification, and retransmits it from a worker.
+        # Therefore, we assume beanstalkd is running locally:
+        c.beanstalk_url = "beanstalk://localhost"
+        #c.beanstalk_url = "beanstalk://127.0.0.1"
+        c.tube_namespace   = "squash-repeater"
+
+        c.max_job_retries = 10 # retry jobs 10 times
+        c.retry_delay = 30 # wait 30 seconds in between retries
+
+        # NB: This relies on forking behaviour!
+        c.default_worker = Backburner::Workers::Forking
+
+        #c.on_error = lambda { |ex| Airbrake.notify(ex) }  #FUTURE: Choose a better failure mode:
+      end
+    end
+
+    def backburner(&p)
+      if block_given?
+        Backburner.configure(&p)
+      else
+        Backburner.configuration
+      end
+    end
+
+    def squash(&p)
+      if block_given?
+        SquashRepeater::Configuration::Squash.configure(&p)
+      else
+        SquashRepeater::Configuration::Squash.configuration
+      end
+    end
+
+    # Return an array of all available loggers
+    def loggers
+      [logger, backburner.logger]  #FUTURE: Can we somehow get a Squash logger for this?
+    end
+
+    def logger=(value)
+      #FUTURE: Can we somehow also set a Squash logger for this?
+      #NB: Squash doesn't allow you to use a different logger
+      @logger = value
+      #NB: Backburner can be quite chatty.  You may prefer to change the default log-level a bit higher because of this.
+      backburner.logger = @logger
+    end
+  end
+end
+
+# This class relies on the class hierarchy having been created (above):
+require "squash_repeater/configure/squash"
+
+# Set the defaults:
+SquashRepeater.configure

data/lib/squash_repeater/exception_queue.rb

@@ -0,0 +1,106 @@
+require "time"
+require "timeout"
+require "backburner"
+
+module SquashRepeater
+  WORKER_ERRORS = [
+    Beaneater::NotConnected,
+    Beaneater::InvalidTubeName,
+    Beaneater::JobNotReserved,
+    Beaneater::UnexpectedResponse
+  ]
+
+  class CaptureTimeoutError < SquashRepeater::Error
+    def to_s
+      original_message = super
+      "Capturing the exception timed-out#{" (#{original_message})" if original_message && !original_message.empty?}"
+    end
+  end
+  WORKER_ERRORS << CaptureTimeoutError
+
+  class << self
+    def transmit_exceptions
+      Backburner.work
+    end
+    alias :work :transmit_exceptions
+
+    # Capture the HTTP data, and store it in the beanstalkd queue for later
+    def capture_exception(url: nil, headers: nil, body: nil, squash_configuration: nil, no_proxy_env: nil)
+      #FUTURE: Required keyword args, for Ruby 2.1+
+      #def capture_exception(url:, headers:, body:, squash_configuration:, no_proxy_env: nil)
+      fail "Missing required keyword arg" unless url && headers && body && squash_configuration
+
+      # If things fail, it's useful to know how long it caused the exception-capture to block the
+      # calling process:
+      start = Time.now
+
+      begin
+        Timeout::timeout(configuration.capture_timeout, CaptureTimeoutError) do
+          #NB: Backburner doesn't seem able to #perform with keyword args:
+          Backburner.enqueue(ExceptionQueue, url, headers, body, squash_configuration, no_proxy_env)
+        end
+
+      rescue *WORKER_ERRORS => e
+        failsafe_handler(
+          e, message: "whilst trying to connect to Beanstalk", time_start: start,
+          args: {
+            url: url,
+            headers: headers,
+            body: body,
+            squash_configuration: squash_configuration,
+            no_proxy_env: no_proxy_env
+          }
+        )
+        raise
+      end
+    end
+    alias :enqueue :capture_exception
+
+    def failsafe_handler(exception, message: nil, time_start: nil, args: {})
+      configuration.logger.error "Failed: #{exception}" + (message && !message.empty? ? ", #{message}." : ".")
+      configuration.logger.error "      : #{exception.inspect}"
+
+      configuration.logger.error "  (Took #{Time.now - time_start}s to fail)" if time_start
+      configuration.logger.error ["*****","  original_args = #{args.inspect}", "*****"].join("\n")
+    end
+  end
+
+  class ExceptionQueue
+    include Backburner::Queue
+    queue "exception"
+
+    # Process one captured Squash notification;  i.e. forward it to the Squash
+    # server
+    def self.perform(url, headers, body, squash_configuration, no_proxy_env=nil)
+      #TODO: Change how Squash client deals with failures.
+      #    Normally it logs to a special log file, whereas what we really want
+      #    is for the job(s) to go back on the queue to be retried.
+
+      # If things fail, it's useful to know how long it caused the exception-capture to block the
+      # calling process:
+      start = Time.now
+
+      #NB: :timeout_protection is a Proc object:
+      squash_configuration = squash_configuration.dup
+
+      #NB: The JSON conversion turns symbol-keys --> strings
+      #NB: Squash::Ruby.configure turns string-keys --> symbols
+      squash_configuration.delete("timeout_protection")
+
+      #NB: This relies on forking behaviour!
+      # We do this, because the queue may be shared, therefore the config may have been different from
+      # each client.
+      Squash::Ruby.configure(squash_configuration)
+      ENV['no_proxy'] = no_proxy_env
+
+      begin
+        # Transmit it to the Squash server:
+        Squash::Ruby.http_transmit__original(url, headers, body)
+
+      rescue SocketError => e
+        SquashRepeater.failsafe_handler(e, message: "whilst trying to connect to Squash", time_start: start)
+        raise
+      end
+    end
+  end
+end

data/lib/squash_repeater/squash_ruby.rb

@@ -0,0 +1,19 @@
+require "squash/ruby"
+
+#FUTURE(willjr): Look into using hooks, to try to decouple the two parts of the lib
+# module Squash::Ruby
+
+# Monkey-patch Squash::Ruby so that instead of immediately sending Squash
+# notifications, capture the HTTP data in the local beanstalk/backburner queue
+module Squash::Ruby
+  class <<self
+    private
+
+    alias :http_transmit__original :http_transmit
+
+    # processing
+    def http_transmit(url, headers, body)
+      SquashRepeater.capture_exception(url: url, headers: headers, body: body, squash_configuration: @configuration, no_proxy_env: ENV["no_proxy"])
+    end
+  end
+end

data/lib/squash_repeater/version.rb

@@ -0,0 +1,3 @@
+module SquashRepeater
+  VERSION = "0.1.6"
+end

data/lib/squash_repeater.rb

@@ -0,0 +1,14 @@
+# Configuration methods are in `configure.rb`
+# Exception capture and re-run are in `exception_queue.rb`
+
+module SquashRepeater
+  class Error < RuntimeError; end
+end
+
+require "squash_repeater/version"
+require "squash_repeater/configure"
+require "squash_repeater/exception_queue"
+require "squash_repeater/squash_ruby"
+
+# For Rails generators (only if Rails is used):
+require "generators/squash_repeater/install_generator" if defined? Rails

data/share/upstart/backburner-manager.conf

@@ -0,0 +1,43 @@
+# /etc/init/backburner-manager.conf
+# - Auto-restart a Backburner worker when the time-stamp of the $app_dir changes.
+# - We assume the changing time-stamp denotes a new deployment of the app.
+
+# This example config should work with Ubuntu 12.04+.  It
+# allows you to manage multiple Backburner instances with
+# Upstart.
+
+env app_name="APP NAME"
+
+# Change to where your app is installed
+env app_dir=
+# Change to where your config is installed; optional
+env app_config=
+
+description "Backburner Manager for '$app_name'"
+
+# This starts upon bootup and stops on shutdown
+start on runlevel [2345]
+stop on runlevel [06]
+
+script
+  start backburner-worker
+
+  while true; do
+    # Gather time-stamp for the app-dir, when started
+    start_app_time=`stat -c %y "$app_dir"`
+    current_app_time=$start_app_time
+
+    logger -t backburner "Time-stamp for '$app_dir' is $start_app_time"
+
+    # Wait for the time-stamp to change:
+    while [ "$current_app_time" = "$start_app_time" ]; do
+      current_app_time=`stat -c %y "$app_dir"`
+      sleep 10
+    done
+
+    logger -t backburner "Time-stamp for '$app_dir' has changed"
+    logger -t backburner "Restarting backburner-worker"
+
+    restart backburner-worker app_name=$app_name app_dir=$app_dir app_config=$app_config
+  done
+end script

data/share/upstart/backburner-worker.conf

@@ -0,0 +1,28 @@
+# /etc/init/backburner-worker.conf - manage a Backburner
+
+# This example config should work with Ubuntu 12.04+.  It
+# allows you to manage multiple Backburner instances with
+# Upstart.
+
+description "Backburner Worker for '$app_name'"
+
+# No "start on", we want backburner-manager to start us
+stop on (stopping backburner-manager or runlevel [06])
+
+# Change to match your deployment user
+setuid backburner_user
+setgid backburner_group
+
+respawn
+respawn limit 3 30
+
+script
+  logger -t backburner "Starting Backburner Worker for '$app_name'"
+
+  cd "$app_dir"
+  if [ "$app_config" ]; then
+    bundle exec backburner -d -P /var/run/backburner.pid -r "$app_config"
+  else
+    bundle exec backburner -d -P /var/run/backburner.pid
+  fi
+end script

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/.bundle/"
+end
+
+require "pry"
+
+#####
+
+require "squash/ruby"
+require "squash_repeater"

data/spec/squash_repeater_configure_squash.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe SquashRepeater::Configuration::Squash do
+  let(:config) { SquashRepeater::Configuration::Squash.configuration }
+  let(:squash_ruby) { class_double("Squash::Ruby").as_stubbed_const(:transfer_nested_constants => true) }
+
+  it do
+    [:set_this, :MosieAlong, :f00b4r].each do |key|
+      expect(squash_ruby).to receive(:configure).with({ key => key.to_s })
+      expect(squash_ruby).to receive(:configuration).with(key)
+      config.send("#{key.to_s}=".to_sym, key.to_s)
+    end
+  end
+
+  it "when setting and getting a Squash config attr" do
+    [:set_this, :MosieAlong, :f00b4r].each do |key|
+      expect(squash_ruby).to receive(:configuration).with(key).and_return(key.to_s)
+      #expect { config.api_key = "Set this" }.to eq "Set this"
+      expect(config.send(key)).to eq key.to_s
+    end
+  end
+end

data/spec/squash_repeater_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+require "stringio"
+require "logger"
+
+describe SquashRepeater do
+  let(:backburner) { class_double("Backburner").as_stubbed_const(:transfer_nested_constants => true) }
+  let(:backburner_enqueue_args) { ["one", "two", :three, {four: "three"}, :five] }
+  let(:capture_exception_args) { {url: "one", headers: "two", body: :three, squash_configuration: {four: "three"}, no_proxy_env: :five} }
+
+  it do
+    expect(backburner).to receive(:work)
+    SquashRepeater.work
+  end
+
+  it do
+    expect(backburner).to receive(:enqueue).with(SquashRepeater::ExceptionQueue, *backburner_enqueue_args)
+    SquashRepeater.capture_exception(**capture_exception_args)
+  end
+
+  context "within #capture_exception" do
+    let!(:logger_output) { StringIO.new }
+
+    around do |eg|
+      _logger = SquashRepeater.configuration.logger
+      SquashRepeater.configuration.logger = Logger.new logger_output
+      eg.run
+      SquashRepeater.configuration.logger = _logger
+    end
+
+    context "the logger output" do
+      it "for a handled error-type should not be empty" do
+        expect(backburner).to receive(:enqueue).with(SquashRepeater::ExceptionQueue, *backburner_enqueue_args).and_raise(Beaneater::NotConnected)
+        expect { SquashRepeater.capture_exception(**capture_exception_args) }.to raise_error
+        expect(logger_output.string).not_to be_empty
+      end
+
+      it "for a non-handled error-type should be empty" do
+        expect(backburner).to receive(:enqueue).with(SquashRepeater::ExceptionQueue, *backburner_enqueue_args).and_raise(KeyError)
+        expect { SquashRepeater.capture_exception(**capture_exception_args) }.to raise_error
+        expect(logger_output.string).to be_empty
+      end
+
+    end
+
+    it do
+      expect(backburner).to receive(:enqueue).with(SquashRepeater::ExceptionQueue, *backburner_enqueue_args).and_raise(Beaneater::NotConnected)
+      expect { SquashRepeater.capture_exception(**capture_exception_args) }.to raise_error
+    end
+
+    #NB: This is technically a medium/large test because of the timeout:
+    it "raises CaptureTimeoutError when worker doesn't return within the timeout" do
+      expect(backburner).to receive(:enqueue).with(SquashRepeater::ExceptionQueue, *backburner_enqueue_args) { sleep SquashRepeater.configuration.capture_timeout + 1 }
+      expect { SquashRepeater.capture_exception(**capture_exception_args) }.to raise_error(SquashRepeater::CaptureTimeoutError)
+    end
+  end
+end
+
+describe SquashRepeater::ExceptionQueue do
+  let(:squash_ruby) { class_double("Squash::Ruby").as_stubbed_const(:transfer_nested_constants => true) }
+
+  it do
+    expect(squash_ruby).to receive(:configure).with(
+      config1: "config1", config2: "config2")
+    expect(squash_ruby).to receive(:http_transmit__original).with(
+      "url", "headers", "body"
+    )
+
+    SquashRepeater::ExceptionQueue.perform(
+      "url", "headers", "body", { config1: "config1", config2: "config2" }
+    )
+  end
+
+  it "configuration dup removes 'timeout_protection'" do
+    expect(squash_ruby).to receive(:configure).with(
+      config1: "config1", config2: "config2")
+    expect(squash_ruby).to receive(:http_transmit__original)
+
+    SquashRepeater::ExceptionQueue.perform(
+      "url", "headers", "body",
+      { config1: "config1", config2: "config2",
+        "timeout_protection" => "should not be here" }
+    )
+  end
+end

data/spec/squash_ruby_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Squash::Ruby do
+  let(:squash_repeater) { class_double("SquashRepeater").as_stubbed_const(:transfer_nested_constants => true) }
+
+  context "with ENV['no_proxy'] unset" do
+    it do
+      #NB: This is a crappy, env-dependent test...
+      expect(ENV["no_proxy"]).to be_nil
+    end
+  end
+
+  context "with ENV['no_proxy'] set" do
+    around do |eg|
+      env_no_proxy = ENV["no_proxy"]
+      ENV["no_proxy"] = "TEST no_proxy"
+      eg.run
+
+      ENV["no_proxy"] = env_no_proxy
+    end
+
+    it do
+      expect(squash_repeater).to receive(:capture_exception).with(url: "url", headers: "headers", body: "body", squash_configuration: nil, no_proxy_env: "TEST no_proxy")
+      Squash::Ruby.class_eval { http_transmit("url", "headers", "body") }
+    end
+  end
+end

data/squash_repeater-ruby.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'squash_repeater/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "squash_repeater"
+  spec.version       = SquashRepeater::VERSION
+  spec.authors       = ["Will Robertson"]
+  spec.email         = ["will.robertson@powershop.co.nz"]
+  spec.summary       = %q{Squash Repeater for Ruby}
+  spec.description   = %q{Use beanstalkd to locally queue and repeat Squash exception capturing.}
+  spec.homepage      = ""
+  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.2"
+  spec.add_development_dependency "simplecov", "~> 0.10"
+  spec.add_development_dependency "pry-byebug", "~> 3.1"
+
+  spec.add_runtime_dependency "squash_ruby", "~> 2.0"
+  spec.add_runtime_dependency "backburner", "~> 0.4"
+  spec.add_runtime_dependency "thor", "~> 0.19"
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: squash_repeater
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Will Robertson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-22 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.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: squash_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: backburner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: Use beanstalkd to locally queue and repeat Squash exception capturing.
+email:
+- will.robertson@powershop.co.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/squash_repeater/install_generator.rb
+- lib/generators/templates/squash_repeater_initializer.rb
+- lib/squash_repeater.rb
+- lib/squash_repeater/configure.rb
+- lib/squash_repeater/configure/squash.rb
+- lib/squash_repeater/exception_queue.rb
+- lib/squash_repeater/squash_ruby.rb
+- lib/squash_repeater/version.rb
+- share/upstart/backburner-manager.conf
+- share/upstart/backburner-worker.conf
+- spec/spec_helper.rb
+- spec/squash_repeater_configure_squash.rb
+- spec/squash_repeater_spec.rb
+- spec/squash_ruby_spec.rb
+- squash_repeater-ruby.gemspec
+homepage: ''
+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.5
+signing_key: 
+specification_version: 4
+summary: Squash Repeater for Ruby
+test_files:
+- spec/spec_helper.rb
+- spec/squash_repeater_configure_squash.rb
+- spec/squash_repeater_spec.rb
+- spec/squash_ruby_spec.rb
+has_rdoc: