failbot 0.9.0

data/bin/failbot

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'failbot'
+Failbot::Server.new(port=ARGV.shift, tmp=ARGV.shift).exec!
+
+# vim:ft=ruby

data/lib/failbot.rb

@@ -0,0 +1,237 @@
+require 'yaml'
+require 'digest/md5'
+require 'logger'
+require 'socket'
+require "uri"
+
+require 'failbot/version'
+require "failbot/compat"
+
+# Failbot asynchronously takes exceptions and reports them to the
+# exception logger du jour. Keeps the main app from failing or lagging if
+# the exception logger service is down or slow.
+module Failbot
+  # The failbot relay server.
+  autoload :Server,   'failbot/server'
+
+  # Interface for posting exception data to haystack.
+  autoload :Haystack, 'failbot/haystack'
+
+  autoload :BERTBackend,   'failbot/bert_backend'
+  autoload :FileBackend,   'failbot/file_backend'
+  autoload :HerokuBackend, 'failbot/heroku_backend'
+  autoload :HTTPBackend,   'failbot/http_backend'
+  autoload :MemoryBackend, 'failbot/memory_backend'
+
+  # Public: Setup the backend for reporting exceptions.
+  def setup(settings={}, default_context={})
+    deprecated_settings = %w[
+      backend host port haystack workers service_logs
+      raise_errors
+    ]
+
+    if settings.empty? ||
+      settings.keys.any? { |key| deprecated_settings.include?(key) }
+      warn "%s Deprecated Failbot.setup usage. See %s for details." % [
+        caller[0], "https://github.com/github/failbot"
+      ]
+      return setup_deprecated(settings)
+    end
+
+    if default_context.respond_to?(:to_hash) && !default_context.to_hash.empty?
+      context[0] = default_context.to_hash
+    end
+
+    self.backend =
+      case (name = settings["FAILBOT_BACKEND"])
+      when "bert"
+        Failbot::BERTBackend.new(URI(settings["FAILBOT_BACKEND_BERT_URL"]))
+      when "memory"
+        Failbot::MemoryBackend.new
+      when "file"
+        Failbot::FileBackend.new(settings["FAILBOT_BACKEND_FILE_PATH"])
+      when "http"
+        Failbot::HTTPBackend.new(URI(settings["FAILBOT_HAYSTACK_URL"]))
+      else
+        raise ArgumentError, "Unknown backend: #{name.inspect}"
+      end
+
+    @raise_errors = !settings["FAILBOT_RAISE"].to_s.empty?
+  end
+
+  # Bring in deprecated methods
+  extend Failbot::Compat
+
+  # Stack of context information to include in the next failbot report. These
+  # hashes are condensed down into one and included in the next report. Don't
+  # mess with this structure directly - use the #push and #pop methods.
+  def context
+    @context ||= [{'server' => hostname}]
+  end
+
+  # Add info to be sent in the next failbot report, should one occur.
+  #
+  # info  - Hash of name => value pairs to include in the exception report.
+  # block - When given, the info is removed from the current context after the
+  #         block is executed.
+  #
+  # Returns the value returned by the block when given; otherwise, returns nil.
+  def push(info={})
+    context.push(info)
+    yield if block_given?
+  ensure
+    pop if block_given?
+  end
+
+  # Remove the last info hash from the context stack.
+  def pop
+    context.pop if context.size > 1
+  end
+
+  # Reset the context stack to a pristine state.
+  def reset!
+    @context = [context[0]]
+  end
+
+  # Public: Sends an exception to the exception tracking service along
+  # with a hash of custom attributes to be included with the report. When the
+  # raise_errors option is set, this method raises the exception instead of
+  # reporting to the exception tracking service.
+  #
+  # e     - The Exception object. Must respond to #message and #backtrace.
+  # other - Hash of additional attributes to include with the report.
+  #
+  # Examples
+  #
+  #   begin
+  #     my_code
+  #   rescue => e
+  #     Failbot.report(e, :user => current_user)
+  #   end
+  #
+  # Returns nothing.
+  def report(e, other = {})
+    if @raise_errors
+      squash_context(exception_info(e), other) # surface problems squashing
+      raise e
+    else
+      report!(e, other)
+    end
+  end
+
+  def report!(e, other = {})
+    data = squash_context(exception_info(e), other)
+    backend.report(data)
+  rescue Object => i
+    # don't fail for any reason
+    logger.debug "FAILBOT: #{data.inspect}" rescue nil
+    logger.debug e.message rescue nil
+    logger.debug e.backtrace.join("\n") rescue nil
+    logger.debug i.message rescue nil
+    logger.debug i.backtrace.join("\n") rescue nil
+  end
+
+  # Public: exceptions that were reported. Only available when using the
+  # memory and file backends.
+  #
+  # Returns an Array of exceptions data Hash.
+  def reports
+    backend.reports
+  end
+
+  # Combines all context hashes into a single hash converting non-standard
+  # data types in values to strings, then combines the result with a custom
+  # info hash provided in the other argument.
+  #
+  # other - Optional array of hashes to also squash in on top of the context
+  #         stack hashes.
+  #
+  # Returns a Hash with all keys and values.
+  def squash_context(*other)
+    merged = {}
+    (context + other).each do |hash|
+      hash.each do |key, value|
+        value = (value.call rescue nil) if value.kind_of?(Proc)
+        merged[key.to_s] =
+          case value
+          when String, Numeric, true, false
+            value.to_s
+          else
+            value.inspect
+          end
+      end
+    end
+    merged
+  end
+
+  # Extract exception info into a simple Hash.
+  #
+  # e - The exception object to turn into a Hash.
+  #
+  # Returns a Hash including a 'class', 'message', 'backtrace', and 'rollup'
+  #   keys. The rollup value is a MD5 hash of the exception class, file, and line
+  #   number and is used to group exceptions.
+  def exception_info(e)
+    backtrace = Array(e.backtrace)[0, 500]
+
+    res = {
+      'class'      => e.class.to_s,
+      'message'    => e.message,
+      'backtrace'  => backtrace.join("\n"),
+      'ruby'       => RUBY_DESCRIPTION,
+      'rollup'     => Digest::MD5.hexdigest("#{e.class}#{backtrace[0]}")
+    }
+
+    if original = (e.respond_to?(:original_exception) && e.original_exception)
+      remote_backtrace  = []
+      remote_backtrace << original.message
+      if original.backtrace
+        remote_backtrace.concat(Array(original.backtrace)[0,500])
+      end
+      res['remote_backtrace'] = remote_backtrace.join("\n")
+    end
+
+    res
+  end
+
+  # Installs an at_exit hook to report exceptions that raise all the way out of
+  # the stack and halt the interpreter. This is useful for catching boot time
+  # errors as well and even signal kills.
+  #
+  # To use, call this method very early during the program's boot to cover as
+  # much code as possible:
+  #
+  #   require 'failbot'
+  #   Failbot.install_unhandled_exception_hook!
+  #
+  # Returns true when the hook was installed, nil when the hook had previously
+  # been installed by another component.
+  def install_unhandled_exception_hook!
+    # only install the hook once, even when called from multiple locations
+    return if @unhandled_exception_hook_installed
+
+    # the $! is set when the interpreter is exiting due to an exception
+    at_exit do
+      boom = $!
+      if boom && !@raise_errors && !boom.is_a?(SystemExit)
+        report(boom, 'argv' => ([$0]+ARGV).join(" "), 'halting' => true)
+      end
+    end
+
+    @unhandled_exception_hook_installed = true
+  end
+
+  def logger
+    @logger ||= Logger.new($stderr)
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+
+  def hostname
+    @hostname ||= Socket.gethostname
+  end
+
+  extend self
+end

data/lib/failbot/bert_backend.rb

@@ -0,0 +1,17 @@
+require 'bertrpc'
+
+module Failbot
+  class BERTBackend
+    def initialize(url)
+      @service = BERTRPC::Service.new(url.host, url.port)
+    end
+
+    def report(data)
+      @service.cast.failbot.report(data)
+    end
+
+    def reports
+      raise NotImplementedError
+    end
+  end
+end

data/lib/failbot/compat.rb

@@ -0,0 +1,157 @@
+module Failbot
+  module Compat
+    # DEPRECATED Reset the backend and optionally override the environment
+    # configuration.
+    #
+    # config - The optional configuration Hash.
+    #
+    # Returns nothing.
+    def setup_deprecated(_config={})
+      config.merge!(_config)
+      @backend = nil
+      @raise_errors = nil
+    end
+
+    # The current "environment". This dictates which section will be read
+    # from the failbot.yml config file.
+    def environment
+      warn "#{caller[0]} Failbot.environment is deprecated and will be " \
+        "removed in subsequent releases."
+      @environment ||= ENV['FAILBOT_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    # Hash of configuration data from lib/failbot/failbot.yml.
+    def config
+      warn "#{caller[0]} Failbot.config is deprecated and will be " \
+        "removed in subsequent releases."
+      @config ||= YAML.load_file(config_file)[environment]
+    end
+
+    # Location of failbot.yml config file.
+    def config_file
+      warn "#{caller[0]} Failbot.config_file is deprecated and will be " \
+        "removed in subsequent releases."
+      File.expand_path('../../failbot/failbot.yml', __FILE__)
+    end
+
+    # The name of the backend that should be used to post exceptions to the
+    # exceptions-collection service. The fellowing backends are available:
+    #
+    # memory - Dummy backend that simply save exceptions in memory. Typically
+    #          used in testing environments.
+    #
+    # bert   - The BERT-RPC backend relays exceptions using the bert library.
+    #          See <https://github.com/mojombo/bert> for details.
+    #
+    # heroku - In-process posting for outside of vpn apps
+    #
+    # file   - Append JSON-encoded exceptions to a file.
+    #
+    # Returns the String backend name. See also `Failbot.backend`.
+    def backend_name
+      warn "#{caller[0]} Failbot.backend_name is deprecated and will be " \
+        "removed in subsequent releases."
+      config['backend']
+    end
+
+    # Determines whether exceptions are raised instead of being reported to
+    # the exception tracking service. This is typically enabled in development
+    # and test environments. When set true, no exception information is reported
+    # and the exception is raised instead. When false (default in production
+    # environments), the exception is reported to the exception tracking service
+    # but not raised.
+    def raise_errors?
+      warn "#{caller[0]} Failbot.raise_errors? is deprecated and will be " \
+        "removed in subsequent releases."
+
+      if @raise_errors.nil?
+        config['raise_errors']
+      else
+        @raise_errors
+      end
+    end
+
+    def raise_errors=(v)
+      warn "#{caller[0]} Failbot.raise_errors= is deprecated and will be " \
+        "removed in subsequent releases."
+      @raise_errors = v
+    end
+
+    # Load and initialize the exception reporting backend as specified by
+    # the 'backend' configuration option.
+    #
+    # Raises ArgumentError for invalid backends.
+    def backend
+      @backend ||= backend!
+    end
+    attr_writer :backend
+
+    def backend!
+      warn "#{caller[0]} Failbot.backend! is deprecated and will be " \
+        "removed in subsequent releases."
+      case backend_name
+      when 'bert'
+        url = URI("bertrpc://#{config["host"]}:#{config["port"]}")
+        Failbot::BERTBackend.new(url)
+      when 'memory'
+        Failbot::MemoryBackend.new
+      when 'file'
+        Failbot::FileBackend.new(config['file_path'])
+      when 'heroku', 'http'
+        if backend_name == "heroku"
+          warn "The Failbot \"heroku\" backend is deprecated. Use \"http\" " \
+            "instead. #{caller[1]}"
+        end
+        Failbot::HerokuBackend.new(config['haystack'])
+      else
+        raise ArgumentError, "Unknown backend: #{backend_name.inspect}"
+      end
+    end
+
+    # The URL where exceptions should be posted. Each exception is converted into
+    # JSON and posted to this URL.
+    def haystack
+      warn "#{caller[0]} Failbot.haystack is deprecated and will be " \
+        "removed in subsequent releases."
+      config['haystack']
+    end
+
+    # Send the exception data to the relay service using
+    # a non-waiting cast call.
+    #
+    # data - Hash of string key => string value pairs.
+    #
+    # Returns nothing.
+    def cast(data)
+      warn "#{caller[0]} Failbot.cast is deprecated and will be " \
+        "removed in subsequent releases."
+      backend.report(data)
+    end
+
+    def service
+      warn "#{caller[0]} Failbot.service is deprecated and will be " \
+        "removed in subsequent releases."
+      @service ||= BERTRPC::Service.new(config['host'], config['port'])
+    end
+
+    alias svc service
+
+    def fail
+      warn "#{caller[0]} Failbot.fail is deprecated and will be " \
+        "removed in subsequent releases."
+      raise "failure failure!"
+    end
+
+    def default_options
+      warn "#{caller[0]} Failbot.default_options is deprecated and will be " \
+        "removed in subsequent releases."
+      context[0]
+    end
+
+    def default_options=(hash)
+      warn "#{caller[0]} Failbot.default_options= is deprecated. Please use " \
+        "Failbot.setup(ENV, context={}) instead."
+      context[0] = hash
+    end
+  end
+end

data/lib/failbot/exit_hook.rb

@@ -0,0 +1,16 @@
+# This file exists so that the unhandled exception hook may easily be injected
+# into programs that don't register it themselves. To use, set RUBYOPT or pass
+# an -r argument to ruby:
+#
+# With RUBYOPT:
+#
+#   RUBYOPT=rfailbot/exit_hook some-program.rb
+#
+# With ruby -r:
+#
+#   ruby -rfailbot/exit_hook some-program.rb
+#
+# Note: it may be necessary to also require rubygems w/ RUBYOPT or -r before
+# requiring failbot/exit_hook.
+require 'failbot'
+Failbot.install_unhandled_exception_hook!

data/lib/failbot/failbot.yml

@@ -0,0 +1,82 @@
+development:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: http://localhost:9393/async
+  workers: 1
+  service_log: /tmp/failbot.log
+  raise_errors: true
+
+test:
+  backend: memory
+  host: localhost
+  port: 6666
+  haystack: http://localhost:9393/async
+  workers: 0
+  raise_errors: true
+
+production:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: https://haystack.githubapp.com/_needles
+  workers: 2
+  service_log: /data/github/current/log/failbot.log
+  raise_errors: false
+
+staging:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: https://haystack.githubapp.com/_needles
+  workers: 1
+  service_log: /data/github/current/log/failbot.log
+  raise_errors: false
+
+standalone:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: https://haystack.githubapp.com/_needles
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false
+
+standalone-staging:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: https://haystack-staging.githubapp.com/async
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false
+
+standalone-ng:
+  backend: bert
+  host: localhost
+  port: 6666
+  haystack: https://haystack-ng.githubapp.com/async
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false
+
+haystack-ng:
+  backend: heroku
+  haystack: https://haystack-ng.githubapp.com/async
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false
+
+heroku:
+  backend: heroku
+  haystack: https://hubble.githubapp.com/async
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false
+
+heroku-staging:
+  backend: heroku
+  haystack: https://hubble-staging.githubapp.com/async
+  service_log: /tmp/failbot.log
+  workers: 1
+  raise_errors: false

data/lib/failbot/file_backend.rb

@@ -0,0 +1,27 @@
+require 'yajl'
+
+module Failbot
+  class FileBackend
+    def initialize(path)
+      @path = path
+
+      if path.to_s.empty?
+        raise ArgumentError, "FAILBOT_BACKEND_FILE_PATH setting required."
+      end
+    end
+
+    def report(data)
+      File.open(@path, 'a') do |file|
+        file.puts(Yajl.dump(data))
+      end
+    end
+
+    def reports
+      reports = []
+      File.foreach(@path) do |line|
+        reports << Yajl.load(line)
+      end
+      reports
+    end
+  end
+end

data/lib/failbot/handler.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'time'
+require 'failbot'
+
+# Reopen stderr/stdout on the logfile if enabled.
+if log_file = Failbot::config['service_log']
+  $stderr.reopen(log_file, 'ab')
+  $stdout.reopen($stderr)
+  [$stderr, $stdout].each { |fd| fd.sync = true }
+end
+warn "failbot handler #$$ starting in #{Failbot::environment} at #{Time.now.iso8601}"
+
+require 'ernie'
+require 'failbot/haystack'
+
+# The Ernie handler implementation responsible for delivering exception reports
+# to the exception backend. The report method is made available as a BERT-RPC
+# service.
+module Failbot::Handler
+  def report(data)
+    Failbot::Haystack.send_data(data)
+    true
+  end
+end
+
+Ernie.expose(:failbot, Failbot::Handler)
+
+# vim:ft=ruby

data/lib/failbot/haystack.rb

@@ -0,0 +1,42 @@
+require 'net/https'
+require 'uri'
+require 'yajl'
+
+module Failbot
+  class Haystack
+    def initialize(url)
+      @url = url
+    end
+
+    def user
+      @url.user || "failbot"
+    end
+
+    def password
+      @url.password
+    end
+
+    def send_data(data)
+      # make a post
+      post = Net::HTTP::Post.new(@url.path)
+      post.set_form_data('json' => Yajl.dump(data))
+
+      if user && password
+        post.basic_auth(user, password)
+      end
+
+      # make request
+      req = Net::HTTP.new(@url.host, @url.port)
+
+      # use SSL if applicable
+      req.use_ssl = true if @url.scheme == "https"
+
+      # push it through
+      req.start { |http| http.request(post) }
+    end
+
+    def self.send_data(data)
+      new(Failbot.haystack).send_data(data)
+    end
+  end
+end

data/lib/failbot/heroku_backend.rb

@@ -0,0 +1,15 @@
+module Failbot
+  class HerokuBackend
+    def initialize(url)
+      @hubble = Failbot::Haystack.new(url)
+    end
+
+    def report(data)
+      @hubble.send_data(data)
+    end
+
+    def reports
+      []
+    end
+  end
+end

data/lib/failbot/http_backend.rb

@@ -0,0 +1,19 @@
+module Failbot
+  class HTTPBackend
+    def initialize(url)
+      if url.to_s.empty?
+        raise ArgumentError, "FAILBOT_HAYSTACK_URL setting required."
+      end
+
+      @haystack = Failbot::Haystack.new(url)
+    end
+
+    def report(data)
+      @haystack.send_data(data)
+    end
+
+    def reports
+      []
+    end
+  end
+end

data/lib/failbot/memory_backend.rb

@@ -0,0 +1,22 @@
+module Failbot
+  class MemoryBackend
+    def initialize
+      @reports = []
+      @fail    = false
+    end
+
+    attr_accessor :reports
+
+    def fail!
+      @fail = true
+    end
+
+    def report(data)
+      if @fail
+        fail
+      end
+
+      @reports << data
+    end
+  end
+end

data/lib/failbot/middleware.rb

@@ -0,0 +1,34 @@
+module Failbot
+  # Rack middleware that rescues exceptions raised from the downstream app and
+  # reports to failbot. The exception is reraised after being sent to haystack
+  # so upstream middleware can still display an error page or whathaveyou.
+  class Rescuer
+    def initialize(app, other)
+      @app   = app
+      @other = other
+    end
+
+    def call(env)
+      start = Time.now
+      @app.call(env)
+    rescue Object => boom
+      elapsed = Time.now - start
+      self.class.report(boom, env, @other.merge(:time => elapsed.to_s))
+      raise
+    end
+
+    def self.report(boom, env, other={})
+      request = Rack::Request.new(env)
+      Failbot.context.push(other.merge({
+        :method       => request.request_method,
+        :user_agent   => env['HTTP_USER_AGENT'],
+        :params       => (request.params.inspect rescue nil),
+        :session      => (request.session.inspect rescue nil),
+        :referrer     => request.referrer,
+        :remote_ip    => request.ip,
+        :url          => request.url
+      }))
+      Failbot.report(boom)
+    end
+  end
+end

data/lib/failbot/resque_failure_backend.rb

@@ -0,0 +1,28 @@
+require 'resque'
+
+module Resque
+  module Failure
+    class Failbot < Base
+      def self.url
+        if ENV['RAILS_ENV'] == 'staging'
+          "http://haystack.stg.github.com/types/exception"
+        else
+          "http://haystack.rs.github.com/types/exception"
+        end
+      end
+
+      def self.count
+        # Fake it for now.
+        Stat[:failed]
+      end
+
+      def save
+        ::Failbot.report(exception,
+          :worker => worker.to_s,
+          :queue  => queue.to_s,
+          :job    => payload['class'].to_s,
+          :args   => payload['args'].inspect)
+      end
+    end
+  end
+end

data/lib/failbot/server.rb

@@ -0,0 +1,53 @@
+require 'failbot'
+require 'tmpdir'
+
+module Failbot
+  # Interface for starting the exception relay server. This class constructs a
+  # temporary config file for ernie and starts the erlang server process.
+  class Server
+    def initialize(port=nil, tmpdir=nil)
+      @port = (port || 6666).to_i
+      @tmp = tmpdir || Dir.tmpdir
+    end
+
+    attr_reader :port
+    attr_reader :tmp
+
+    def workers
+      Failbot.config['workers'] || 1
+    end
+
+    def handler_file
+      File.expand_path('../handler.rb', __FILE__)
+    end
+
+    def pid_file
+      "#{@tmp}/failbot.#{port}.pid"
+    end
+
+    def configure
+      write_config
+      config_file
+    end
+
+    def config_file
+      "#{@tmp}/ernie.failbot.#{Failbot.environment}.cfg"
+    end
+
+    def write_config
+      File.open(config_file, 'wb') do |io|
+        io.write((<<-ERLANG).gsub(/^ {10}/, ''))
+          [{module, failbot},
+           {type, external},
+           {command, "ruby #{handler_file}"},
+           {count, #{workers}}].
+        ERLANG
+      end
+    end
+
+    def exec!
+      configure
+      exec "ernie", "-p", port.to_s, "-P", pid_file, "-d", "-c", config_file
+    end
+  end
+end

data/lib/failbot/version.rb

@@ -0,0 +1,3 @@
+module Failbot
+  VERSION = "0.9.0"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: failbot
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- ! '@rtomayko'
+- ! '@atmos'
+- ! '@sr'
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: bertrpc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+description: ! '...'
+email:
+- github+failbot@lists.github.com
+executables:
+- failbot
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/failbot.rb
+- lib/failbot/bert_backend.rb
+- lib/failbot/compat.rb
+- lib/failbot/exit_hook.rb
+- lib/failbot/failbot.yml
+- lib/failbot/file_backend.rb
+- lib/failbot/handler.rb
+- lib/failbot/haystack.rb
+- lib/failbot/heroku_backend.rb
+- lib/failbot/http_backend.rb
+- lib/failbot/memory_backend.rb
+- lib/failbot/middleware.rb
+- lib/failbot/resque_failure_backend.rb
+- lib/failbot/server.rb
+- lib/failbot/version.rb
+- bin/failbot
+homepage: http://github.com/github/failbot#readme
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Deliver exceptions to Haystack
+test_files: []