toadhopper 0.7 → 0.8

data/.gitignore

@@ -0,0 +1,7 @@
+/dist/
+.yardoc
+/doc/bin
+vendor
+bin
+doc
+toadhopper.gemspec

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+-r
+README.md
+-
+LICENSE

data/Gemfile

@@ -0,0 +1,16 @@
+only :release do
+  gem 'haml', '~> 2.0'
+end
+
+only :development do
+  gem 'mg'
+  gem 'yard'
+  gem 'jeweler'
+end
+
+only :test do
+  gem 'rake'
+  gem 'nokogiri'
+  gem 'test-unit', :require_as => 'test/unit'
+end
+

data/README.md

@@ -4,12 +4,35 @@ Toadhopper can be used to report plain old Ruby exceptions, or to build a framew
 
     require 'toadhopper'
 
-    Toadhopper.api_key = "YOURAPIKEY"
+    dispatcher = Toadhopper::Dispatcher.new("YOURAPIKEY")
 
     error = begin; raise "Kaboom!"; rescue => e; e; end
 
-    puts Toadhopper.post!(error)
+    puts dispatcher.post!(error)
 
 You can install it via rubygems:
 
     gem install toadhopper
+
+## Development
+
+Firstly, `gem install bundler`, then:
+
+    % git clone git://github.com/toolmantim/toadhopper.git
+    % cd toadhopper
+    % gem bundle
+    % bin/rake test
+
+If you set a `HOPTOAD_API_KEY` environment variable it'll test actually posting to the Hoptoad API. For example:
+
+    % bin/rake test HOPTOAD_API_KEY=abc123
+
+To generate the docs:
+
+    % bin/yardoc
+
+## Contributors
+
+* [Tim Lucas](http://github.com/toolmantim)
+* [Samuel Tesla](http://github.com/stesla)
+* [atmos](http://github.com/atmos)

data/Rakefile

@@ -1,3 +1,5 @@
+Bundler.require_env(:development)
+
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
@@ -6,18 +8,19 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
-begin
-  gem "sr-mg", "<= 0.0.5"
-  require "mg"
-  MG.new("toadhopper.gemspec")
-rescue Gem::LoadError
-end
+Jeweler::Tasks.new do |s|
+  s.name     = "toadhopper"
+  s.summary  = "Post error notifications to Hoptoad"
+  s.email    = "t.lucas@toolmantim.com"
+  s.homepage = "http://github.com/toolmantim/toadhopper"
+  s.authors  = ["Tim Lucas", "Samuel Tesla", "Corey Donohoe"]
+  s.version  = "0.8"
+  s.extra_rdoc_files  = ["README.md", "LICENSE"]
+  s.executables = nil # stops jeweler automatically adding bin/*
 
-begin
-  gem "yard"
-  require 'yard'
-  YARD::Rake::YardocTask.new do |t|
-    t.options = ['-r', 'Readme.md', '--files', 'LICENSE'] # optional
+  require 'bundler'
+  bundler_env = Bundler::Environment.load(File.dirname(__FILE__) + '/Gemfile')
+  bundler_env.dependencies.each do |d|
+    s.add_dependency(d.name, d.version) if d.in?(:release)
   end
-rescue Gem::LoadError
 end

data/lib/backtrace.rb

@@ -0,0 +1,31 @@
+module ToadHopper
+  # A line in a ruby Backtrace
+  #
+  # @private
+  class BacktraceLine < Struct.new(:file, :number, :method); end
+
+  # A collection of BacktraceLines representing an entire ruby backtrace
+  #
+  # @private
+  class Backtrace
+    INPUT_FORMAT = %r{^([^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+    # the collection of lines in the backtrace
+    attr_reader :lines
+
+    # create a collection of BacktraceLines from an exception
+    def self.from_exception(exception)
+      @lines = exception.backtrace.map do |line|
+        _, file, number, method = line.match(INPUT_FORMAT).to_a
+        BacktraceLine.new(file, number, method)
+      end
+    end
+
+    # iterate over the lines in a Backtrace
+    def each_line(&block)
+      lines.each do |line|
+        yield line
+      end
+    end
+  end
+end

data/lib/notice.haml

@@ -0,0 +1,34 @@
+!!!XML
+%notice{:version => '2.0.0'}
+  %api-key= api_key
+  %notifier
+    %name= notifier_name
+    %version= notifier_version
+    %url http://github.com/toolmantim/toadhopper
+  %error
+    %class= error.class.name
+    %message= "#{error.class.name}: #{error.message}"
+    %backtrace
+      - backtrace.each do |line|
+        %line{:method => line.method, :file => line.file, :number => line.number}
+  %request
+    %url= url
+    %component= component
+    - if action && !action.blank?
+      %action= action
+    - if request && request.params.any?
+      %params
+        - request.params.each do |key,value|
+          %var{:key => key}= value
+    - if session && session.any?
+      %session
+        - session.each do |key,value|
+          %var{:key => key}= value
+    - if environment && environment.any?
+      %cgi-data
+        - environment.each do |key,value|
+          %var{:key => key}= value
+
+  %server-environment
+    %project-root= Dir.pwd
+    %environment-name= framework_env

data/lib/toadhopper.rb

@@ -1,80 +1,153 @@
+root = File.expand_path(File.dirname(__FILE__))
 require 'net/http'
-require 'yaml'
+require 'haml'
+require 'haml/engine'
+require 'nokogiri'
+require File.join(root, 'backtrace')
 
-module Toadhopper
-class << self
-  # Set the API key
-  def api_key=(key)
-    @api_key = key
-  end
-  # Returns the API key
-  def api_key
-    @api_key
-  end
-  # Sets patterns to [FILTER] out sensitive data such as passwords, emails and credit card numbers.
-  #
-  #   Toadhopper.filters = /password/, /email/, /credit_card_number/
-  def filters=(*filters)
-    @filters = filters.flatten
-  end
-  # Returns the filters
-  def filters
-    [@filters].flatten.compact
-  end
-  # Posts an error to Hoptoad
-  def post!(error, options={}, header_options={})
-    uri = URI.parse("http://hoptoadapp.com/notices/")
-    Net::HTTP.start(uri.host, uri.port) do |http|
-      headers = {
-        'Content-type'             => 'application/x-yaml',
-        'Accept'                   => 'text/xml, application/xml',
-        'X-Hoptoad-Client-Name'    => 'Toadhopper',
-      }.merge(header_options)
-      http.read_timeout = 5 # seconds
-      http.open_timeout = 2 # seconds
-      begin
-        http.post uri.path, {"notice" => notice_params(error, options)}.to_yaml, headers
-      rescue TimeoutError => e
-        nil
+module ToadHopper
+  # Hoptoad API response
+  class Response < Struct.new(:status, :body, :errors); end
+
+  # Posts errors to the Hoptoad API
+  class Dispatcher
+    attr_reader :api_key
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+    
+    # Sets patterns to [FILTER] out sensitive data such as passwords, emails and credit card numbers.
+    #
+    #   Toadhopper::Dispatcher.new('apikey').filters = /password/, /email/, /credit_card_number/
+    def filters=(*filters)
+      @filters = filters.flatten
+    end
+
+    # Filters for the Dispatcher
+    #
+    # @return [Regexp]
+    def filters
+      [@filters].flatten.compact
+    end
+
+    # Posts an exception to hoptoad.
+    #   Toadhopper::Dispatcher.new('apikey').post!(exception, {:action => 'show', :controller => 'Users'})
+    # The Following Keys are available as parameters to the document_options
+    #   error            The actual exception to be reported
+    #   api_key          The api key for your project
+    #   url              The url for the request, required to post but not useful in a console environment
+    #   component        Normally this is your Controller name in an MVC framework
+    #   action           Normally the action for your request in an MVC framework
+    #   request          An object that response to #params and returns a hash
+    #   notifier_name    Say you're a different notifier than ToadHopper
+    #   notifier_version Specify the version of your custom notifier
+    #   session          A hash of the user session in a web request
+    #   framework_env    The framework environment your app is running under
+    #   backtrace        Normally not needed, parsed automatically from the provided exception parameter
+    #   environment      You MUST scrub your environment if you plan to use this, please do not use it though. :)
+    #
+    # @return Toadhopper::Response
+    def post!(error, document_options={}, header_options={})
+      post_document(document_for(error, document_options), header_options)
+    end
+
+    # Posts a v2 document error to Hoptoad
+    # header_options can be passed in to indicate you're posting from a separate client
+    #   Toadhopper::Dispatcher.new('API KEY').post_document(doc, 'X-Hoptoad-Client-Name' => 'MyCustomDispatcher')
+    #
+    # @private
+    def post_document(document, header_options={})
+      uri = URI.parse("http://hoptoadapp.com:80/notifier_api/v2/notices")
+
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        headers = {
+          'Content-type'             => 'text/xml',
+          'Accept'                   => 'text/xml, application/xml',
+          'X-Hoptoad-Client-Name'    => 'Toadhopper',
+        }.merge(header_options)
+        http.read_timeout = 5 # seconds
+        http.open_timeout = 2 # seconds
+        begin
+          response = http.post uri.path, document, headers
+          response_for(response)
+        rescue TimeoutError => e
+          Response.new(500, '', ['Timeout error'])
+        end
       end
-     end
-  end
-  private
-    # Replaces the values of the keys matching Toadhopper.filters with [FILTERED]. Typically used on the params and environment hashes.
+    end
+
+    # @private
+    def document_for(exception, options={})
+      locals = {
+        :error            => exception,
+        :api_key          => api_key,
+        :environment      => scrub_environment(ENV.to_hash),
+        :backtrace        => Backtrace.from_exception(exception),
+        :url              => 'http://localhost/',
+        :component        => 'http://localhost/',
+        :action           => nil,
+        :request          => nil,
+        :notifier_name    => 'ToadHopper',
+        :notifier_version => '0.8',
+        :session          => { },
+        :framework_env    => ENV['RACK_ENV'] || 'development' }.merge(options)
+
+      Haml::Engine.new(notice_template).render(Object.new, locals)
+    end
+
+    # @private
+    def response_for(http_response)
+      status = Integer(http_response.code)
+      case status
+      when 422
+        errors = Nokogiri::XML.parse(http_response.body).xpath('//errors/error')
+        Response.new(status, http_response.body, errors.map { |error| error.content })
+      else
+        Response.new(status, http_response.body, [])
+      end
+    end
+
+    # @private
     def filter(hash)
       hash.inject({}) do |acc, (key, val)|
-        acc[key] = filters.any? {|f| key.to_s =~ Regexp.new(f)} ? "[FILTERED]" : val
-        acc
+        acc[key] = filter?(key) ? "[FILTERED]" : val
+      acc
       end
     end
-    def notice_params(error, options={}) # :nodoc:
-      clean_non_serializable_data(stringify_keys(
-        {
-          :api_key       => api_key,
-          :error_class   => error.class.name,
-          :error_message => error.message,
-          :backtrace     => error.backtrace,
-        }.merge(options)
-      ))
+
+    # @private
+    def filter?(key)
+      filters.any? do |filter|
+        key.to_s =~ Regexp.new(filter)
+      end
+    end
+
+    # @private
+    def scrub_environment(hash)
+      filter(clean_non_serializable_data(hash))
     end
-    def stringify_keys(hash) #:nodoc:
-      hash.inject({}) do |h, pair|
-        h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+
+    # @private
+    def clean_non_serializable_data(data)
+      data.select{|k,v| serializable?(v) }.inject({}) do |h, pair|
+        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
         h
       end
     end
-    def serializable?(value) #:nodoc:
+
+    # @private
+    def serializable?(value)
       value.is_a?(Fixnum) ||
       value.is_a?(Array) ||
       value.is_a?(String) ||
       value.is_a?(Hash) ||
       value.is_a?(Bignum)
     end
-    def clean_non_serializable_data(data) #:nodoc:
-      data.select{|k,v| serializable?(v) }.inject({}) do |h, pair|
-        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
-        h
-      end
+
+    # @private
+    def notice_template
+      File.read(::File.join(::File.dirname(__FILE__), 'notice.haml'))
     end
+  end
 end
-end

data/test/helper.rb

@@ -0,0 +1,3 @@
+Bundler.require_env(:test)
+
+require File.join(File.dirname(__FILE__), "..", "lib", "toadhopper")

data/test/test_filter.rb

@@ -1,28 +1,30 @@
-require File.dirname(__FILE__) + "/../lib/toadhopper"
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
-require 'test/unit'
-
-class Toadhopper::TestFilter < Test::Unit::TestCase
-  def setup
-    Toadhopper.filters = nil
+class ToadHopper::Dispatcher::TestFilter < Test::Unit::TestCase
+  def dispatcher
+    @dispatcher ||= ToadHopper::Dispatcher.new("test api key")
   end
+  
   def test_no_filters
     assert_equal(                 {:id => "myid", :password => "mypassword"},
-                 Toadhopper.filter(:id => "myid", :password => "mypassword"))
+                 dispatcher.filter(:id => "myid", :password => "mypassword"))
   end
+
   def test_string_filter
-    Toadhopper.filters = "pass"
+    dispatcher.filters = "pass"
     assert_equal(                 {:id => "myid", :password => "[FILTERED]"},
-                 Toadhopper.filter(:id => "myid", :password => "mypassword"))
+                 dispatcher.filter(:id => "myid", :password => "mypassword"))
   end
+
   def test_regex_filter
-    Toadhopper.filters = /pas{2}/
+    dispatcher.filters = /pas{2}/
     assert_equal(                 {:id => "myid", :password => "[FILTERED]"},
-                 Toadhopper.filter(:id => "myid", :password => "mypassword"))
+                 dispatcher.filter(:id => "myid", :password => "mypassword"))
   end
+
   def test_multiple_filters
-    Toadhopper.filters = "email", /pas{2}/
+    dispatcher.filters = "email", /pas{2}/
     assert_equal(                 {:id => "myid", :email => "[FILTERED]", :password => "[FILTERED]"},
-                 Toadhopper.filter(:id => "myid", :email => "myemail", :password => "mypassword"))
+                 dispatcher.filter(:id => "myid", :email => "myemail", :password => "mypassword"))
   end
 end

data/test/test_posting.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class ToadHopper::Dispatcher::TestPosting < Test::Unit::TestCase
+  def test_posting
+    dispatcher = ToadHopper::Dispatcher.new("abc123")
+    error = begin; raise "Kaboom!"; rescue => e; e end
+
+    response = dispatcher.post!(error)
+    assert_equal 422, response.status
+    assert_equal ['No project exists with the given API key.'], response.errors
+  end
+
+  if ENV['HOPTOAD_API_KEY']
+    def test_posting_integration
+      dispatcher = ToadHopper::Dispatcher.new(ENV['HOPTOAD_API_KEY'])
+      error = begin; raise "Kaboom!"; rescue => e; e end
+
+      response = dispatcher.post!(error)
+      assert_equal 200, response.status
+      assert_equal [], response.errors
+    end
+  end
+end

data/test/test_setters.rb

@@ -1,22 +1,18 @@
-require File.dirname(__FILE__) + "/../lib/toadhopper"
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
-require 'test/unit'
-
-class Toadhopper::TestSetters < Test::Unit::TestCase
-  def setup
-    Toadhopper.api_key = nil
-    Toadhopper.filters = nil
-  end
+class ToadHopper::Dispatcher::TestSetters < Test::Unit::TestCase
   def test_setting_api_key
-    Toadhopper.api_key = "abc123"
-    assert_equal "abc123", Toadhopper.api_key
+    dispatcher = ToadHopper::Dispatcher.new('abc123')
+    assert_equal "abc123", dispatcher.api_key
   end
   def test_setting_single_filter
-    Toadhopper.filters = /password/
-    assert_equal [/password/], Toadhopper.filters
+    dispatcher = ToadHopper::Dispatcher.new('')
+    dispatcher.filters = /password/
+    assert_equal [/password/], dispatcher.filters
   end
   def test_setting_multple_filters
-    Toadhopper.filters = /password/, /email/
-    assert_equal [/password/, /email/], Toadhopper.filters
+    dispatcher = ToadHopper::Dispatcher.new('')
+    dispatcher.filters = /password/, /email/
+    assert_equal [/password/, /email/], dispatcher.filters
   end
 end

metadata

@@ -1,40 +1,59 @@
 --- !ruby/object:Gem::Specification 
 name: toadhopper
 version: !ruby/object:Gem::Version 
-  version: "0.7"
+  version: "0.8"
 platform: ruby
 authors: 
 - Tim Lucas
+- Samuel Tesla
+- Corey Donohoe
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-09-17 00:00:00 +10:00
+date: 2009-12-15 00:00:00 +11:00
 default_executable: 
-dependencies: []
-
-description: Post error notifications to Hoptoad
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: haml
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+description: 
 email: t.lucas@toolmantim.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- Readme.md
+- LICENSE
+- README.md
 files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- LICENSE
 - README.md
 - Rakefile
-- LICENSE
+- lib/backtrace.rb
+- lib/notice.haml
 - lib/toadhopper.rb
+- test/helper.rb
 - test/test_filter.rb
-- test/test_notice_params.rb
+- test/test_posting.rb
 - test/test_setters.rb
-- Readme.md
 has_rdoc: true
 homepage: http://github.com/toolmantim/toadhopper
-post_install_message: 
-rdoc_options: []
+licenses: []
 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -51,10 +70,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: toadhopper
-rubygems_version: 1.3.1
+rubyforge_project: 
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Post error notifications to Hoptoad
-test_files: []
-
+test_files: 
+- test/helper.rb
+- test/test_filter.rb
+- test/test_posting.rb
+- test/test_setters.rb

data/Readme.md

@@ -1,15 +0,0 @@
-A base library for [Hoptoad](http://www.hoptoadapp.com/) error reporting.
-
-Toadhopper can be used to report plain old Ruby exceptions, or to build a framework-specific gem such as [toadhopper-sinatra](http://github.com/toolmantim/toadhopper-sinatra).
-
-    require 'toadhopper'
-
-    Toadhopper.api_key = "YOURAPIKEY"
-
-    error = begin; raise "Kaboom!"; rescue => e; e; end
-
-    puts Toadhopper.post!(error)
-
-You can install it via rubygems:
-
-    gem install toadhopper

data/test/test_notice_params.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + "/../lib/toadhopper"
-
-require 'test/unit'
-
-class Toadhopper::TestNoticeParams < Test::Unit::TestCase
-  def test_notice_params
-    Toadhopper.api_key = "abc123"
-    error = begin; raise "Kaboom!"; rescue => e; e end
-    def error.backtrace; ["backtrace line 1", "backtrace line 2"] end
-    assert_equal({
-      "api_key"       => "abc123",
-      "error_class"   => "RuntimeError",
-      "error_message" => "Kaboom!",
-      "backtrace"     => ["backtrace line 1", "backtrace line 2"],
-      "request"       => {"request_var" => "request_val"},
-      "environment"   => {"env_var" => "env_val"},
-      "session"       => {"session_var" => "session_val"},
-      },
-      Toadhopper.notice_params(
-        error,
-        {
-          "request" => {"request_var" => "request_val"},
-          "environment" => {"env_var" => "env_val"},
-          "session" => {"session_var" => "session_val"}
-        }
-      )
-    )
-  end
-end