hoptoad-ribbit 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## EDITOR
+*.kpf
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+*.ignore

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2007, Tammer Saleh, Thoughtbot, Inc.
+Copyright (c) 2009 Glen Mailer
+
+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.rdoc

@@ -0,0 +1,22 @@
+= Ribbit
+
+This Hoptoad Notifier attempts to remove anything rails specific from the
+original notifier released by Thoughtbot.
+
+My intention is to have a completely rails-free core - and then provide
+adapters for popular frameworks - firstly Merb as thats what I'm using,
+and then subsequently things like Rails and Rack.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Glen Mailer. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "hoptoad-ribbit"
+    gem.summary = "Generic Hoptoad Notifications and an adapter for merb"
+    gem.description = %q{
+      Provides a Module to handle sending notifications to hoptoad.
+
+      Currently includes a Merb adapter, but the intention is to add more later.
+    }
+    gem.email = "glenjamin@gmail.com"
+    gem.homepage = "http://github.com/glenjamin/hoptoad-notifier"
+    gem.authors = ["Glen Mailer"]
+    gem.add_dependency "builder", ">= 2.0.0"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ribbit #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/hoptoad-ribbit.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hoptoad-ribbit}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Glen Mailer"]
+  s.date = %q{2010-01-05}
+  s.description = %q{
+      Provides a Module to handle sending notifications to hoptoad.
+
+      Currently includes a Merb adapter, but the intention is to add more later.
+    }
+  s.email = %q{glenjamin@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "hoptoad-ribbit.gemspec",
+     "lib/ribbit.rb",
+     "lib/ribbit/adapters.rb",
+     "lib/ribbit/adapters/adapter.rb",
+     "lib/ribbit/adapters/merb.rb",
+     "lib/ribbit/adapters/none.rb",
+     "lib/ribbit/backtrace.rb",
+     "lib/ribbit/configuration.rb",
+     "lib/ribbit/notice.rb",
+     "lib/ribbit/sender.rb",
+     "spec/ribbit_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/glenjamin/hoptoad-notifier}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Generic Hoptoad Notifications and an adapter for merb}
+  s.test_files = [
+    "spec/ribbit_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<builder>, [">= 2.0.0"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<builder>, [">= 2.0.0"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<builder>, [">= 2.0.0"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/ribbit.rb

@@ -0,0 +1,100 @@
+require 'ribbit/configuration'
+require 'ribbit/notice'
+require 'ribbit/sender'
+require 'ribbit/backtrace'
+require 'ribbit/adapters'
+require 'ribbit/adapters/adapter'
+
+module Ribbit
+  CLIENT_NAME = "Ribbit"
+  VERSION = "0.1.0.dev"
+  API_VERSION = "2.0"
+  LOG_PREFIX = "** [Ribbit] "
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Hoptoad server.
+    # Must respond to #send_to_hoptoad. See Ribbit::Sender.
+    attr_accessor :sender
+
+    # A Hoptoad configuration object. Must act like a hash and return sensible
+    # values for all Hoptoad configuration options. See Ribbit::Configuration.
+    attr_accessor :configuration
+
+    # The adapter allows different things to happen on different environments
+    # Basicially we proxy some methods through to subclasses of
+    # Ribbit::Adapters::Adapter
+    attr_accessor :adapter
+
+    # Collection of all existing adapters
+    def adapters
+      Ribbit::Adapters.adapters
+    end
+
+    # Proxy logger onto the adapter
+    def logger
+      adapter.logger if adapter
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Ribbit.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure = false
+    #   end
+    def configure(silent = false)
+      self.configuration ||= Configuration.new
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      # Attempt to attach an adapter, either by class or name
+      if adapters.include? configuration.adapter
+        self.adapter = configuration.adapter.new(configuration)
+      elsif configuration.adapter
+        adapter_class = Ribbit::Adapters.load_adapter configuration.adapter
+        self.adapter = adapter_class.new(configuration) rescue nil
+      end
+      self.adapter.activate! if self.adapter
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Hoptoad about.
+    # @param [Hash] opts Data that will be sent to Hoptoad.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Hoptoad uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :request The controller's request object.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment ENV merged with the contents of the request's environment.
+    def notify(exception, opts = {})
+      send_notice(build_notice_for(exception, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see Ribbit.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        sender.send_to_hoptoad(notice.to_xml)
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      if exception.respond_to?(:to_hash)
+        opts = opts.merge(exception)
+      else
+        opts = opts.merge(:exception => exception)
+      end
+
+      Notice.new(configuration.merge(opts))
+    end
+
+  end
+end

data/lib/ribbit/adapters.rb

@@ -0,0 +1,39 @@
+module Ribbit
+  module Adapters
+    class << self
+
+      attr_accessor :adapters
+
+      def adapters
+        @adapters ||= []
+      end
+
+      # Register a new adapter - you do not need to call this directly if subclassing Adapter
+      def add_adapter(adapter)
+        self.adapters << adapter
+      end
+
+      def load_adapter(name)
+        require_adapter!(name)
+        adapter_class_name = name.to_s.capitalize
+        Ribbit::Adapters.const_get(adapter_class_name) rescue nil
+      end
+
+      private
+
+      def adapter_path(name)
+        name = name.to_s.downcase
+        File.join(File.dirname(__FILE__), 'adapters', "#{name}.rb")
+      end
+
+      def require_adapter!(name)
+        begin
+          require adapter_path(name)
+        rescue LoadError
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/ribbit/adapters/adapter.rb

@@ -0,0 +1,29 @@
+module Ribbit
+  module Adapters
+    class Adapter
+
+      attr_accessor :configuration
+
+      class << self
+        def inherited(klass)
+          Ribbit::Adapters.add_adapter klass
+        end
+      end
+
+      def initialize(config)
+        self.configuration = config
+      end
+
+      # This should provide something that implements the logger interface
+      def logger
+        raise NotImplementedError
+      end
+
+      # This should perform the steps to integrate hoptoad catching into the framework
+      def activate!
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/ribbit/adapters/merb.rb

@@ -0,0 +1,53 @@
+module Ribbit
+  module Adapters
+    class Merb < Adapter
+
+      def initialize(config)
+        super(config)
+        config.environment_name = ::Merb.env
+        config.project_root = ::Merb.root
+      end
+
+      def logger
+        ::Merb.logger
+      end
+
+      def activate!
+        ::Merb::BootLoader.after_app_loads do
+          ::Merb::AbstractController.send(:include, ControllerMixin)
+          if configuration.automatic?
+            ::Merb::Dispatcher::DefaultException.send(:include, ControllerMixin)
+            ::Merb::Dispatcher::DefaultException.send(:include, DefaultExceptionExtensions)
+          end
+        end
+      end
+
+      module ControllerMixin
+        protected
+
+        def notify_hoptoad(ex=nil)
+          exceptions = request.exceptions || [ex]
+          exceptions.each do |exception|
+            Ribbit.notify(exception, {
+              :parameters => params,
+              :session => session,
+              :controller => params[:controller],
+              :action => params[:action],
+              :url => absolute_url(:this),
+              :cgi_data => ENV.to_hash.merge(request.env)
+            })
+          end
+        end
+      end # ControllerMixin
+
+      module DefaultExceptionExtensions
+        def self.included(mod)
+          mod.class_eval do
+            before :notify_hoptoad
+          end
+        end
+      end
+
+    end # class Merb
+  end # module Adapters
+end # module Ribbit

data/lib/ribbit/adapters/none.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+module Ribbit
+  module Adapters
+    class None < Adapter
+
+      # This should provide something that implements the logger interface
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      # This should perform the steps to integrate hoptoad catching into the framework
+      def activate!
+
+      end
+
+    end
+  end
+end

data/lib/ribbit/backtrace.rb

@@ -0,0 +1,99 @@
+module Ribbit
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Handles backtrace parsing line by line
+    class Line
+
+      INPUT_FORMAT = %r{^([^:]+):(\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 ==(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

data/lib/ribbit/configuration.rb

@@ -0,0 +1,234 @@
+module Ribbit
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+
+    OPTIONS = [:adapter, :api_key, :automatic, :backtrace_filters,
+        :development_environments, :development_lookup, :environment_filters,
+        :environment_name, :host, :http_open_timeout, :http_read_timeout,
+        :ignore, :ignore_by_filters, :ignore_user_agent, :notifier_name,
+        :notifier_url, :notifier_version, :params_filters, :project_root,
+        :port, :protocol, :proxy_host, :proxy_pass, :proxy_port, :proxy_user,
+        :secure].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # The host to connect to (defaults to hoptoadapp.com).
+    attr_accessor :host
+
+    # The port on which your Hoptoad server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Hoptoad.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_reader :params_filters
+
+    # A list of environment keys that should be filtered out of what is send to Hoptoad.
+    # Empty by default.
+    attr_reader :environment_filters
+
+    # A list of filters for cleaning and pruning the backtrace. See #filter_backtrace.
+    attr_reader :backtrace_filters
+
+    # A list of filters for ignoring exceptions. See #ignore_by_filter.
+    attr_reader :ignore_by_filters
+
+    # A list of exception classes to ignore. The array can be appended to.
+    attr_reader :ignore
+
+    # A list of user agents that are being ignored. The array can be appended to.
+    attr_reader :ignore_user_agent
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # +true+ if errors should be caught automatically
+    attr_accessor :automatic
+    alias_method :automatic?, :automatic
+
+    # +true+ if you want to check for production errors matching development errors, +false+ otherwise.
+    attr_accessor :development_lookup
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The adapter to use to plug functionality into the parent application
+    attr_accessor :adapter
+
+    # The path to the project in which the error occurred, such as the RAILS_ROOT
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such as "Hoptoad Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(Ribbit.configuration.project_root)
+          line.gsub(/#{Ribbit.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/ribbit} }
+    ].freeze
+
+    IGNORE_DEFAULT = []
+
+    # Some of these don't exist for whatever the app is, so we have to consider that.
+    IGNORE_DEFAULT.map!{|e| eval(e) rescue nil }.compact!
+    IGNORE_DEFAULT.freeze
+
+    alias_method :secure?, :secure
+
+    def initialize
+      @secure                   = false
+      @host                     = 'hoptoadapp.com'
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @environment_filters      = []
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @ignore_by_filters        = []
+      @ignore                   = IGNORE_DEFAULT.dup
+      @ignore_user_agent        = []
+      @development_environments = %w(development test)
+      @automatic                = true
+      @development_lookup       = true
+      @notifier_name            = CLIENT_NAME
+      @notifier_version         = VERSION
+      @notifier_url             = 'http://hoptoadapp.com'
+    end
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary.
+    #
+    # @example
+    #   config.filter_bracktrace do |line|
+    #     line.gsub(/^#{Rails.root}/, "[RAILS_ROOT]")
+    #   end
+    #
+    # @param [Proc] block The new backtrace filter.
+    # @yieldparam [String] line A line in the backtrace.
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    # Takes a block and adds it to the list of ignore filters.
+    # When the filters run, the block will be handed the exception.
+    # @example
+    #   config.ignore_by_filter do |exception_data|
+    #     true if exception_data[:error_class] == "RuntimeError"
+    #   end
+    #
+    # @param [Proc] block The new ignore filter
+    # @yieldparam [Hash] data The exception data given to +Ribbit.notify+
+    # @yieldreturn [Boolean] If the block returns true the exception will be ignored, otherwise it will be processed by hoptoad.
+    def ignore_by_filter(&block)
+      self.ignore_by_filters << block
+    end
+
+    # Overrides the list of default ignored errors.
+    #
+    # @param [Array<Exception>] names A list of exceptions to ignore.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Overrides the list of default ignored user agents
+    #
+    # @param [Array<String>] A list of user agents to ignore
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash.merge(option.to_sym => send(option))
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    private
+
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+
+  end
+
+end

data/lib/ribbit/notice.rb

@@ -0,0 +1,283 @@
+require 'builder'
+
+module Ribbit
+  class Notice
+
+    # The exception that caused this notice, if any
+    attr_reader :exception
+
+    # The API key for the project to which this notice should be sent
+    attr_reader :api_key
+
+    # The backtrace from the given exception or hash.
+    attr_reader :backtrace
+
+    # The name of the class of error (such as RuntimeError)
+    attr_reader :error_class
+
+    # The name of the server environment (such as "production")
+    attr_reader :environment_name
+
+    # CGI variables such as HTTP_METHOD
+    attr_reader :cgi_data
+
+    # The message from the exception, or a general description of the error
+    attr_reader :error_message
+
+    # See Configuration#backtrace_filters
+    attr_reader :backtrace_filters
+
+    # See Configuration#params_filters
+    attr_reader :params_filters
+
+    # A hash of parameters from the query string or post body.
+    attr_reader :parameters
+    alias_method :params, :parameters
+
+    # The component (if any) which was used in this request (usually the controller)
+    attr_reader :component
+    alias_method :controller, :component
+
+    # The action (if any) that was called in this request
+    attr_reader :action
+
+    # A hash of session data from the request
+    attr_reader :session_data
+
+    # The path to the project that caused the error (usually RAILS_ROOT)
+    attr_reader :project_root
+
+    # The URL at which the error occurred (if any)
+    attr_reader :url
+
+    # See Configuration#ignore
+    attr_reader :ignore
+
+    # See Configuration#ignore_by_filters
+    attr_reader :ignore_by_filters
+
+    # The name of the notifier library sending this notice, such as "Hoptoad Notifier"
+    attr_reader :notifier_name
+
+    # The version number of the notifier library sending this notice, such as "2.1.3"
+    attr_reader :notifier_version
+
+    # A URL for more information about the notifier library sending this notice
+    attr_reader :notifier_url
+
+    def initialize(args)
+      self.args         = args
+      self.exception    = args[:exception]
+      self.api_key      = args[:api_key]
+      self.project_root = args[:project_root]
+      self.url          = args[:url]
+
+      self.notifier_name    = args[:notifier_name]
+      self.notifier_version = args[:notifier_version]
+      self.notifier_url     = args[:notifier_url]
+
+      self.ignore              = args[:ignore]              || []
+      self.ignore_by_filters   = args[:ignore_by_filters]   || []
+      self.backtrace_filters   = args[:backtrace_filters]   || []
+      self.params_filters      = args[:params_filters]      || []
+      self.parameters          = args[:parameters]          || {}
+      self.component           = args[:component] || args[:controller]
+      self.action              = args[:action]
+
+      self.environment_name = args[:environment_name]
+      self.cgi_data         = args[:cgi_data] || ENV
+      self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller))
+      self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
+      self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{exception.class.name}: #{exception.message}"
+      end
+
+      find_session_data
+      clean_params
+    end
+
+    # Converts the given notice to XML
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct!
+      xml = builder.notice(:version => Ribbit::API_VERSION) do |notice|
+        notice.tag!("api-key", api_key)
+        notice.notifier do |notifier|
+          notifier.name(notifier_name)
+          notifier.version(notifier_version)
+          notifier.url(notifier_url)
+        end
+        notice.error do |error|
+          error.tag!('class', error_class)
+          error.message(error_message)
+          error.backtrace do |backtrace|
+            self.backtrace.lines.each do |line|
+              backtrace.line(:number => line.number,
+                             :file   => line.file,
+                             :method => line.method)
+            end
+          end
+        end
+        if url ||
+            controller ||
+            action ||
+            !parameters.empty? ||
+            !cgi_data.empty? ||
+            !session_data.empty?
+          notice.request do |request|
+            request.url(url)
+            request.component(controller)
+            request.action(action)
+            unless parameters.empty?
+              request.params do |params|
+                xml_vars_for(params, parameters)
+              end
+            end
+            unless session_data.empty?
+              request.session do |session|
+                xml_vars_for(session, session_data)
+              end
+            end
+            unless cgi_data.empty?
+              request.tag!("cgi-data") do |cgi_datum|
+                xml_vars_for(cgi_datum, cgi_data)
+              end
+            end
+          end
+        end
+        notice.tag!("server-environment") do |env|
+          env.tag!("project-root", project_root)
+          env.tag!("environment-name", environment_name)
+        end
+      end
+      xml.to_s
+    end
+
+    # Determines if this notice should be ignored
+    def ignore?
+      ignored_class_names.include?(error_class) ||
+        ignore_by_filters.any? {|filter| filter.call(self) }
+    end
+
+    # Allows properties to be accessed using a hash-like syntax
+    #
+    # @example
+    #   notice[:error_message]
+    # @param [String] method The given key for an attribute
+    # @return The attribute value, or self if given +:request+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    attr_writer :exception, :api_key, :backtrace, :error_class, :error_message,
+      :backtrace_filters, :parameters, :params_filters,
+      :environment_filters, :session_data, :project_root, :url, :ignore,
+      :ignore_by_filters, :notifier_name, :notifier_url, :notifier_version,
+      :component, :action, :cgi_data, :environment_name
+
+    # Arguments given in the initializer
+    attr_accessor :args
+
+    # Gets a property named +attribute+ of an exception, either from an actual
+    # exception or a hash.
+    #
+    # If an exception is available, #from_exception will be used. Otherwise,
+    # a key named +attribute+ will be used from the #args.
+    #
+    # If no exception or hash key is available, +default+ will be used.
+    def exception_attribute(attribute, default = nil, &block)
+      (exception && from_exception(attribute, &block)) || args[attribute] || default
+    end
+
+    # Gets a property named +attribute+ from an exception.
+    #
+    # If a block is given, it will be used when getting the property from an
+    # exception. The block should accept and exception and return the value for
+    # the property.
+    #
+    # If no block is given, a method with the same name as +attribute+ will be
+    # invoked for the value.
+    def from_exception(attribute)
+      if block_given?
+        yield(exception)
+      else
+        exception.send(attribute)
+      end
+    end
+
+    # Removes non-serializable data from the given attribute.
+    # See #clean_unserializable_data
+    def clean_unserializable_data_from(attribute)
+      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
+    end
+
+    # Removes non-serializable data. Allowed data types are strings, arrays,
+    # and hashes. All other types are converted to strings.
+    # TODO: move this onto Hash
+    def clean_unserializable_data(data)
+      if data.respond_to?(:to_hash)
+        data.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.collect do |value|
+          clean_unserializable_data(value)
+        end
+      else
+        data.to_s
+      end
+    end
+
+    # Replaces the contents of params that match params_filters.
+    # TODO: extract this to a different class
+    def clean_params(from=nil)
+      clean_unserializable_data_from(:parameters)
+      from ||= parameters
+      if params_filters
+        from.keys.each do |key|
+          from[key] = "[FILTERED]" if params_filters.any? do |filter|
+            key.to_s.include?(filter)
+          end
+          # Recurse inside nested param hashes
+          clean_params(from[key]) if from[key].respond_to?(:keys)
+        end
+      end
+    end
+
+    def find_session_data
+      self.session_data = args[:session_data] || args[:session] || {}
+      self.session_data = session_data[:data] if session_data[:data]
+    end
+
+    # Converts the mixed class instances and class names into just names
+    # TODO: move this into Configuration or another class
+    def ignored_class_names
+      ignore.collect do |string_or_class|
+        if string_or_class.respond_to?(:name)
+          string_or_class.name
+        else
+          string_or_class
+        end
+      end
+    end
+
+    def xml_vars_for(builder, hash)
+      hash.each do |key, value|
+        if value.respond_to?(:to_hash)
+          builder.var(:key => key){|b| xml_vars_for(b, value.to_hash) }
+        elsif value.respond_to?(:to_ary)
+          builder.var("[" << (value.map { |v| v.to_s } * ", ") << "]", :key => key)
+        else
+          builder.var(value.to_s, :key => key)
+        end
+      end
+    end
+  end
+end

data/lib/ribbit/sender.rb

@@ -0,0 +1,70 @@
+require 'net/http'
+require 'net/https'
+
+module Ribbit
+  # Sends out the notice to Hoptoad
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    HEADERS = {
+      'Content-type' => 'text/xml',
+      'Accept' => 'text/xml, application/xml'
+    }
+
+    def initialize(options = {})
+      [:proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+        :host, :port, :secure, :http_open_timeout, :http_read_timeout].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Hoptoad for processing.
+    #
+    # @param [String] data The XML notice to be sent off
+    def send_to_hoptoad(data)
+      log :debug, "Sending request to #{url.to_s}:\n#{data}"
+
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+      http.use_ssl      = secure
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue TimeoutError => e
+                   log :error, "Timeout while contacting the Hoptoad server."
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :info, "Success: #{response.class}"
+        log :debug, "Response Body: #{response.body}"
+      else
+        log :error, "Failure: #{response.class}"
+        log :debug, "Response Body: #{response.body}"
+      end
+    end
+
+    private
+
+    attr_reader :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+      :host, :port, :secure, :http_open_timeout, :http_read_timeout
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(level, message)
+      logger.send level, LOG_PREFIX + message if logger
+    end
+
+    def logger
+      Ribbit.logger
+    end
+
+  end
+end

data/spec/ribbit_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Ribbit do
+
+  it "should have a name for the client field in the API" do
+    Ribbit.client_name.should_not be_nil
+  end
+
+  it "should have a version number for the client" do
+    Ribbit.client_version.should_not be_nil
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ribbit'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: hoptoad-ribbit
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Glen Mailer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-05 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: "\n      Provides a Module to handle sending notifications to hoptoad.\n\n      Currently includes a Merb adapter, but the intention is to add more later.\n    "
+email: glenjamin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- hoptoad-ribbit.gemspec
+- lib/ribbit.rb
+- lib/ribbit/adapters.rb
+- lib/ribbit/adapters/adapter.rb
+- lib/ribbit/adapters/merb.rb
+- lib/ribbit/adapters/none.rb
+- lib/ribbit/backtrace.rb
+- lib/ribbit/configuration.rb
+- lib/ribbit/notice.rb
+- lib/ribbit/sender.rb
+- spec/ribbit_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/glenjamin/hoptoad-notifier
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Generic Hoptoad Notifications and an adapter for merb
+test_files: 
+- spec/ribbit_spec.rb
+- spec/spec_helper.rb