hydraulic_brake 0.0.0

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p194

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p194@airbrake --create

data/.yardopts

@@ -0,0 +1,2 @@
+-
+MIT-LICENSE

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+gem "builder"
+
+group "development" do
+  gem "bourne", ">= 1.0"
+  gem "cucumber", "~> 0.10.6"
+  gem "fakeweb", "~> 1.3.0"
+  gem "jeweler"
+  gem "nokogiri", "~> 1.4.3.1"
+  gem "rake"
+  gem "rspec", "~> 2.6.0"
+  gem "shoulda", "~> 2.11.3"
+  gem "simplecov"
+  gem "yard"
+end

data/INSTALL

@@ -0,0 +1,20 @@
+=== Configuration
+
+You should have something like this in config/initializers/hydraulic_brake.rb.
+
+  HydraulicBrake.configure do |config|
+    config.api_key = '1234567890abcdef'
+  end
+
+(Please note that this configuration should be in a global configuration, and
+is *not* environment-specific. HydraulicBrake is smart enough to know what
+errors are caused by what environments, so your staging errors don't get mixed
+in with your production errors.)
+
+You can test that HydraulicBrake is working in your production environment by
+using this rake task:
+
+  rake hydraulicbrake:test
+
+If everything is configured properly, that task will send a notice to Airbrake
+which will be visible immediately.

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007 - 2012, Exceptional DBA Airbrake.io
+
+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,103 @@
+HydraulicBrake
+========
+
+This is a replacement notifier gem for the [Airbrake
+gem](https://github.com/airbrake/airbrake) which is used
+for integrating ruby apps with [Airbrake](http://airbrake.io).
+
+### Transitioning from Airbrake to HydraulicBrake
+
+HydraulicBrake is a lighter weight alternative to the [Airbrake
+gem](https://github.com/airbrake/airbrake) and takes a different design
+approach. HydraulicBrake doesn't attempt to integrate with any
+frameworks and has few dependencies. HydraulicBrake doesn't change
+anything outside its own namespace. It doesn't do any automatic
+exception handling or configuration.
+
+Configuration
+-------------
+
+Configure HydraulicBrake when your app starts with a configuration block
+like this one:
+
+    HydraulicBrake.configure do |config|
+      config.host = "api.airbrake.io"
+      config.port = "443"
+      config.secure = true
+      config.environment_name = "staging"
+      config.api_key = "<api-key-from-your-airbrake-server>"
+    end
+
+Usage
+-----
+
+Wherever you want to notify an Airbrake server, just call
+HydraulicBrake#notify
+
+    begin
+      params = {
+        # params that you pass to a method that can throw an exception
+      }
+      my_unpredicable_method(params)
+    rescue => e
+      HydraulicBrake.notify(
+        :error_class   => "Special Error",
+        :error_message => "Special Error: #{e.message}",
+        :parameters    => params
+      )
+    end
+
+HydraulicBrake merges the hash you pass with these default options:
+
+    {
+      :api_key       => HydraulicBrake.api_key,
+      :error_message => 'Notification',
+      :backtrace     => caller,
+      :parameters    => {},
+      :session       => {}
+    }
+
+You can override any of those parameters.
+
+Async Notifications
+-------------------
+
+HydraulicBrake doesn't provide anything for async notifications, and
+that's a good thing. Just wrap your calls to Airbrake#notify in the
+async library of your choice.
+
+Proxy Support
+-------------
+
+The notifier supports using a proxy, if your server is not able to
+directly reach the Airbrake servers. To configure the proxy settings,
+added the following information to your HydraulicBrake configuration
+block.
+
+    HydraulicBrake.configure do |config|
+      config.proxy_host = proxy.host.com
+      config.proxy_port = 4038
+      config.proxy_user = foo # optional
+      config.proxy_pass = bar # optional
+      
+Logging
+------------
+
+HydraulicBrake uses STDOUT by default. If you don't like HydraulicBrake
+scribbling to your standard output, just pass another `Logger` instance
+inside your configuration:
+
+    HydraulicBrake.configure do |config|
+      ...
+      config.logger = Logger.new("path/to/your/log/file")
+    end
+
+Credits
+-------
+
+Thank you to all [the airbrake contributors](https://github.com/airbrake/airbrake/contributors)!
+
+License
+-------
+
+Airbrake is Copyright © 2008-2012 Airbrake. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "hydraulic_brake"
+  gem.homepage = "http://github.com/stevecrozz/hydraulic_brake"
+  gem.license = "MIT"
+  gem.summary = "Simple Airbrake client"
+  gem.description = %Q{Sends notifications to an Airbrake server}
+  gem.email = "stevecrozz@gmail.com"
+  gem.authors = ["Stephen Crosby"]
+  gem.require_paths = ["lib"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/features/rake.feature

@@ -0,0 +1,27 @@
+Feature: Use the Gem to catch errors in a Rake application
+  Background:
+    Given I have built and installed the "airbrake" gem
+
+  Scenario: Catching exceptions in Rake
+    When I run rake with airbrake
+    Then Airbrake should catch the exception
+
+  Scenario: Falling back to default handler before Airbrake is configured
+    When I run rake with airbrake not yet configured
+    Then Airbrake should not catch the exception
+
+  Scenario: Disabling Rake exception catcher
+    When I run rake with airbrake disabled
+    Then Airbrake should not catch the exception
+
+  Scenario: Autodetect, running from terminal
+    When I run rake with airbrake autodetect from terminal
+    Then Airbrake should not catch the exception
+
+  Scenario: Autodetect, not running from terminal
+    When I run rake with airbrake autodetect not from terminal
+    Then Airbrake should catch the exception
+
+  Scenario: Sending the correct component name
+    When I run rake with airbrake
+    Then Airbrake should send the rake command line as the component name

data/features/step_definitions/rake_steps.rb

@@ -0,0 +1,17 @@
+When /I run rake with (.+)/ do |command|
+  @rake_command = "rake #{command.gsub(' ','_')}"
+  @rake_result = `cd features/support/rake && GEM_HOME=#{BUILT_GEM_ROOT} #{@rake_command} 2>&1`
+end
+
+Then /Airbrake should (|not) ?catch the exception/ do |condition|
+  if condition=='not'
+    @rake_result.should_not =~ /^airbrake/
+  else
+    @rake_result.should =~ /^airbrake/
+  end
+end
+
+Then /Airbrake should send the rake command line as the component name/ do
+  component = @rake_result.match(/^airbrake (.*)$/)[1]
+  component.should == @rake_command
+end

data/features/support/matchers.rb

@@ -0,0 +1,35 @@
+RSpec::Matchers.define :have_content do |xpath, content|
+  match do |document|
+    @elements = document.search(xpath)
+
+    if @elements.empty?
+      false
+    else
+      element_with_content = document.at("#{xpath}[contains(.,'#{content}')]")
+
+      if element_with_content.nil?
+        @found = @elements.collect { |element| element.content }
+
+        false
+      else
+        true
+      end
+    end
+  end
+
+  failure_message_for_should do |document|
+    if @elements.empty?
+      "In XML:\n#{document}\nNo element at #{xpath}"
+    else
+      "In XML:\n#{document}\nGot content #{@found.inspect} at #{xpath} instead of #{content.inspect}"
+    end
+  end
+
+  failure_message_for_should_not do |document|
+    unless @elements.empty?
+      "In XML:\n#{document}\nExpcted no content #{content.inspect} at #{xpath}"
+    end
+  end
+end
+
+World(RSpec::Matchers)

data/features/support/rake/Rakefile

@@ -0,0 +1,61 @@
+# A test harness for RakeHandler
+#
+require 'rake'
+require 'rubygems'
+require 'hydraulic_brake'
+require 'hydraulic_brake/rake_handler'
+
+HydraulicBrake.configure do |c|
+end
+
+# Should catch exception
+task :hydraulic_brake do
+  HydraulicBrake.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  raise_exception 
+end
+
+# Should not catch exception
+task :hydraulic_brake_disabled do
+  HydraulicBrake.configuration.rescue_rake_exceptions = false
+  stub_tty_output(true)
+  raise_exception 
+end
+
+# Should not catch exception as tty_output is true
+task :hydraulic_brake_autodetect_from_terminal do
+  HydraulicBrake.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(true) 
+  raise_exception 
+end
+
+# Should catch exception as tty_output is false
+task :hydraulic_brake_autodetect_not_from_terminal do
+  HydraulicBrake.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(false) 
+  raise_exception 
+end
+
+task :hydraulic_brake_not_yet_configured do
+  HydraulicBrake.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  stub_empty_sender
+  raise_exception
+end
+
+def stub_empty_sender
+  HydraulicBrake.sender = nil
+end
+
+def stub_tty_output(value)
+  Rake.application.instance_eval do
+    @tty_output_stub = value
+    def tty_output?
+      @tty_output_stub
+    end
+  end
+end
+
+def raise_exception
+  raise 'TEST'
+end

data/features/support/terminal.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+
+Before do
+  @terminal = Terminal.new
+end
+
+After do |story|
+  if story.failed?
+    # puts @terminal.output
+  end
+end
+
+class Terminal
+  attr_reader :output, :status
+  attr_accessor :environment_variables, :invoke_heroku_rake_tasks_locally
+
+  def initialize
+    @cwd = FileUtils.pwd
+    @output = ""
+    @status = 0
+    @logger = Logger.new(File.join(TEMP_DIR, 'terminal.log'))
+
+    @invoke_heroku_rake_tasks_locally = false
+
+    @environment_variables = {
+      "GEM_HOME" => LOCAL_GEM_ROOT,
+      "GEM_PATH" => "#{LOCAL_GEM_ROOT}:#{BUILT_GEM_ROOT}",
+      "PATH" => "#{gem_bin_path}:#{ENV['PATH']}"
+    }
+  end
+
+  def cd(directory)
+    @cwd = directory
+  end
+
+  def run(command)
+    command = optionally_invoke_heroku_rake_tasks_locally(command)
+
+    output << "#{command}\n"
+    FileUtils.cd(@cwd) do
+      # The ; forces ruby to shell out so the env settings work right
+      cmdline = "#{environment_settings} #{command} 2>&1 ; "
+      logger.debug(cmdline)
+      result = `#{cmdline}`
+      logger.debug(result)
+      output << result
+    end
+    @status = $?
+  end
+
+  def optionally_invoke_heroku_rake_tasks_locally(command)
+    if invoke_heroku_rake_tasks_locally
+      command.sub(/^heroku /, '')
+    else
+      command
+    end
+  end
+
+  def echo(string)
+    logger.debug(string)
+  end
+
+  def flush!
+    @output = ""
+  end
+
+  def build_and_install_gem(gemspec)
+    pkg_dir = File.join(TEMP_DIR, 'pkg')
+    FileUtils.mkdir_p(pkg_dir)
+    output = `gem build #{gemspec} 2>&1`
+    gem_file = Dir.glob("*.gem").first
+    unless gem_file
+      raise "Gem didn't build:\n#{output}"
+    end
+    target = File.join(pkg_dir, gem_file)
+    FileUtils.mv(gem_file, target)
+    install_gem_to(LOCAL_GEM_ROOT, target)
+  end
+
+  def install_gem(gem)
+    install_gem_to(LOCAL_GEM_ROOT, gem)
+  end
+
+  def uninstall_gem(gem)
+    `gem uninstall -i #{LOCAL_GEM_ROOT} #{gem}`
+  end
+
+  def prepend_path(path)
+    @environment_variables['PATH'] = path + ":" + @environment_variables['PATH']
+  end
+
+  private
+
+  def install_gem_to(root, gem)
+    `gem install -i #{root} --no-ri --no-rdoc #{gem}`
+  end
+
+  def environment_settings
+    @environment_variables.map { |key, value| "#{key}=#{value}" }.join(' ')
+  end
+
+  def gem_bin_path
+    File.join(LOCAL_GEM_ROOT, "bin")
+  end
+
+  attr_reader :logger
+end

data/hydraulic_brake.gemspec

@@ -0,0 +1,102 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "hydraulic_brake"
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stephen Crosby"]
+  s.date = "2013-07-14"
+  s.description = "Sends notifications to an Airbrake server"
+  s.email = "stevecrozz@gmail.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".rbenv-version",
+    ".rvmrc",
+    ".yardopts",
+    "Gemfile",
+    "INSTALL",
+    "MIT-LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "features/rake.feature",
+    "features/step_definitions/rake_steps.rb",
+    "features/support/matchers.rb",
+    "features/support/rake/Rakefile",
+    "features/support/terminal.rb",
+    "hydraulic_brake.gemspec",
+    "lib/hydraulic_brake.rb",
+    "lib/hydraulic_brake/backtrace.rb",
+    "lib/hydraulic_brake/configuration.rb",
+    "lib/hydraulic_brake/notice.rb",
+    "lib/hydraulic_brake/sender.rb",
+    "lib/hydraulic_brake/version.rb",
+    "lib/hydraulic_brake_tasks.rb",
+    "resources/README.md",
+    "resources/ca-bundle.crt",
+    "script/integration_test.rb",
+    "test/airbrake_2_3.xsd",
+    "test/backtrace_test.rb",
+    "test/configuration_test.rb",
+    "test/helper.rb",
+    "test/logger_test.rb",
+    "test/notice_test.rb",
+    "test/notifier_test.rb",
+    "test/recursion_test.rb",
+    "test/sender_test.rb"
+  ]
+  s.homepage = "http://github.com/stevecrozz/hydraulic_brake"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "Simple Airbrake client"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<builder>, [">= 0"])
+      s.add_development_dependency(%q<bourne>, [">= 1.0"])
+      s.add_development_dependency(%q<cucumber>, ["~> 0.10.6"])
+      s.add_development_dependency(%q<fakeweb>, ["~> 1.3.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<nokogiri>, ["~> 1.4.3.1"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.11.3"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<bourne>, [">= 1.0"])
+      s.add_dependency(%q<cucumber>, ["~> 0.10.6"])
+      s.add_dependency(%q<fakeweb>, ["~> 1.3.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, ["~> 1.4.3.1"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<bourne>, [">= 1.0"])
+    s.add_dependency(%q<cucumber>, ["~> 0.10.6"])
+    s.add_dependency(%q<fakeweb>, ["~> 1.3.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, ["~> 1.4.3.1"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

data/lib/hydraulic_brake/backtrace.rb

@@ -0,0 +1,108 @@
+module HydraulicBrake
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Handles backtrace parsing line by line
+    class Line
+
+      # regexp (optionnally allowing leading X: for windows support)
+      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line)
+        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+        new(file, number, method)
+      end
+
+      def initialize(file, number, method)
+        self.file   = file
+        self.number = number
+        self.method = method
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      private
+
+      attr_writer :file, :number, :method
+    end
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end.compact
+
+      lines = filtered_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end