coalmine 0.5.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.DS_Store
+.rvmrc
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in coalmine.gemspec
+gemspec
+
+group :test, :development do
+  # Pretty printed test output
+  gem 'turn', :require => false
+  gem 'rspec-rails'
+  gem 'fakeweb'
+end

data/README.md

@@ -0,0 +1,65 @@
+# Ruby Connector for Coalmine
+
+This connector allows you to easily send errors and log messages to the Coalmine API.
+
+## Setup
+
+Rails 3.x:
+
+    gem "coalmine"
+    
+## Configuration
+
+In a Rails app create an initializer and configure as such:
+
+    Coalmine.configure do |config|
+      config.signature = "my_secret_signature"
+      config.logger = Rails.logger
+    end
+
+All uncaught exceptions are automatically logged. To manually log an exception to coalmine:
+
+    begin
+      call_dangerous_method
+    rescue Exception => e
+      notify_coalmine(e)
+    end
+    
+## Usage
+
+To notify Coalmine of a deployment
+
+    rake coalmine:deployment[your_version,username]
+    
+    # For example
+    rake coalmine:deployment[1.0.0,brad]
+    
+## Filtering sensitive information
+
+Coalmine will automatically string-replace values that you deem to be sensitive and do not want to be sent out.
+Coalmine automatically honors `Rails.application.config.filter_parameters`. If you wish to include additional filter properties, you can via the config:
+
+    Coalmine.configure do |config|
+      config.filters += ["credit-card"]
+    end
+    
+The above would replace all properties named `credit-card` with the value [FILTERED].
+
+## Setting custom variables to included with notifications
+
+You can include extra information by defining custom variables. These are automatically appended to the notification sent to Coalmine and appear in the 'Application' tab. Custom variables are added like so:
+
+    Coalmine.custom_variables[:username] = current_user.username
+    
+You will most likely initialize all your custom application variables at the beginning of the request. If you are using Rails, it might look something like:
+
+    class ApplicationController < ApplicationController::Base
+      before_filter :set_custom_variables
+      
+    protected
+      
+      def set_custom_variables
+        Coalmine.custom_variables[:user_name] = current_user.username
+        Coalmine.custom_variables[:something] = "another custom value"
+      end
+    end

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+Rspec::Core::RakeTask.new

data/coalmine.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "coalmine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "coalmine"
+  s.version     = Coalmine::VERSION
+  s.authors     = ["Brad Seefeld", "Matt Ratzloff"]
+  s.email       = ["admin@coalmineapp.com"]
+  s.homepage    = "https://github.com/coalmine/coalmine_ruby"
+  s.summary     = "Coalmine Connector Ruby implementation"
+  s.description = "Send errors to the Coalmine API for logging and analytics."
+
+  s.rubyforge_project = "coalmine"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakeweb"
+  s.add_runtime_dependency "jsonbuilder"
+end

data/lib/coalmine/capistrano.rb

@@ -0,0 +1,33 @@
+require "capistrano"
+
+module Coalmine
+  module Capistrano
+    def self.setup(config)
+      config.load do
+        after "deploy", "coalmine:deploy"
+        
+        namespace :coalmine do
+          desc "Notify Coalmine of the deployment"
+          task :deploy, :except => { :no_release => true } do
+            environment = fetch(:rails_env, :production)
+            author = ENV["USER"] || ENV["USERNAME"]
+            rake = fetch(:rake, :rake)
+            cmd = "cd #{config.current_release} && RAILS_ENV=#{environment} #{rake} coalmine:deployment[#{current_revision},#{author}]"
+            logger.info "Notifying Coalmine of Deploy"
+            if config.dry_run
+              logger.info "Dry Run... Coalmine will not actually be notified"
+            else
+              run(cmd, :once => true) { |ch, stream, data| result << data }
+            end
+            
+            logger.info "Coalmine notification completed."
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Coalmine::Capistrano.setup(Capistrano::Configuration.instance)
+end

data/lib/coalmine/configuration.rb

@@ -0,0 +1,37 @@
+class Coalmine::Configuration
+  
+  attr_accessor :url, :environment, :signature, :logger, :host, :port, :proxy_host, 
+      :proxy_port, :proxy_user, :proxy_password, :protocol, :secure, :http_open_timeout,
+      :http_read_timeout, :project_root, :framework, :filters,
+      
+      # For HTTP basic auth
+      :http_user, :http_password,
+      
+      # The application version
+      :version,
+      
+      # The environments for which notifications can be posted
+      :enabled_environments
+  
+  def initialize
+    self.protocol = "https"
+    self.host = "coalmineapp.com"
+    self.port = 443
+    self.secure = true
+    self.enabled_environments = ["production", "staging"]
+    
+    self.http_open_timeout = 3
+    self.http_read_timeout = 6
+    self.logger = Coalmine::Logger.new
+    self.filters = []
+  end
+   
+  def protocol=(proto)
+    proto = "http" unless ["http", "https"].include?(proto)
+    @protocol = proto
+  end
+  
+  def secure?
+    self.secure
+  end
+end

data/lib/coalmine/logger.rb

@@ -0,0 +1,16 @@
+module Coalmine
+  class Logger
+    
+    def error(*msg)
+    end
+    
+    def warn(*msg)
+    end
+    
+    def info(*msg)
+    end
+    
+    def debug(*msg)
+    end
+  end
+end

data/lib/coalmine/notification.rb

@@ -0,0 +1,186 @@
+require "jsonbuilder"
+require "socket"
+
+##
+# Contains all data sent to the API. Responsible for serializing data into the
+# correct format.
+# 
+# @link http://rack.rubyforge.org/doc/files/SPEC.html
+module Coalmine
+  class Notification
+    
+    attr_accessor :stack_trace, :message, :line_number, :url, 
+        :error_class, :controller, :action, :method, :parameters, 
+        :ip_address, :user_agent, :cookies, :environment, :server,
+        :severity, :hostname, :process_id, :file, :referrer, :thread_id
+        
+    def initialize(args = {})
+      
+      exception = args[:exception]
+      
+      if exception
+        self.stack_trace = exception.backtrace * "\n" if exception.backtrace
+        self.message     = exception.message
+        self.error_class = exception.class.name
+        self.line_number = extract_line_number(exception.backtrace)
+        self.file        = extract_file_name(exception.backtrace)
+      end
+      
+      if args[:rack_env]
+        set_from_rack_env(args[:rack_env])
+      end
+            
+      args.keys.each do |key|
+        setter = :"#{key}="
+        send(setter, args[key]) if respond_to?(setter)
+      end
+      
+      self.severity = "ERROR" unless self.severity
+      self.hostname = Socket.gethostname
+      
+      begin
+        self.process_id = Process::pid
+      rescue
+        # Ignore
+      end
+      
+      begin
+        self.thread_id = Thread.current.object_id
+      rescue
+        # Ignore
+      end
+    end
+    
+    def post_data
+      {:signature => Coalmine.config.signature, :json => to_json}
+    end
+    
+    def to_json(options = {})
+      ActiveSupport::JSON.encode(serialize(options))
+    end
+    
+    def serialize(options)
+      config = Coalmine.config
+      results = {
+        :version         => config.version, 
+        :app_environment => config.environment,
+        :url             => url,
+        :file            => file,
+        :line_number     => line_number,
+        :message         => message, 
+        :stack_trace     => stack_trace, 
+        :class           => error_class, 
+        :framework       => config.framework, 
+        :parameters      => parameters, 
+        :ip_address      => ip_address, 
+        :user_agent      => user_agent, 
+        :cookies         => cookies, 
+        :method          => method,
+        :environment     => environment,
+        :server          => server,
+        :severity        => severity,
+        :hostname        => hostname,
+        :process_id      => process_id,
+        :thread_id       => thread_id.to_s, # Because it is a long
+        :referrer        => referrer,
+        :application     => Coalmine.custom_variables
+      }
+      
+      Coalmine.filter(results)
+    end
+    
+    ##
+    # Remote resource path
+    #
+    # @return [String] The path of the remote resource. Will be appended to the remote base URL.
+    def resource_path
+      "/notify/"
+    end
+  
+  protected
+    
+    def set_from_rack_env(env)
+      return unless env
+      
+      self.url        = assemble_url(env)
+      self.ip_address = env["REMOTE_ADDR"]
+      self.user_agent = env["HTTP_USER_AGENT"]
+      self.method     = env["REQUEST_METHOD"]
+      self.cookies    = env["HTTP_COOKIE"]
+      self.parameters = env["QUERY_STRING"]
+      
+      begin
+        require "rack/request"
+        request = ::Rack::Request.new(env) # Always returns the same request object
+        self.referrer   = request.referrer if request.respond_to? :referrer
+      rescue
+        # Ignore
+      end
+      
+      environment_keys = ["GATEWAY_INTERFACE", "PATH_INFO", "QUERY_STRING", "REMOTE_ADDR",
+        "REMOTE_HOST", "REQUEST_METHOD", "REQUEST_URI", "SCRIPT_NAME", "SERVER_NAME", 
+        "SERVER_PORT", "SERVER_PROTOCOL", "SERVER_SOFTWARE", "HTTP_HOST", "HTTP_CONNECTION", 
+        "HTTP_USER_AGENT", "HTTP_ACCEPT", "HTTP_ACCEPT_ENCODING", "HTTP_ACCEPT_LANGUAGE", 
+        "HTTP_ACCEPT_CHARSET", "HTTP_COOKIE"]
+      self.environment = {}
+      environment_keys.each do |key|
+        self.environment[key] = env[key].to_s
+      end
+      
+      server_keys = ["HTTP_CACHE_CONTROL", "rack.version", "rack.multithread", "rack.multiprocess",
+        "rack.run_once", "rack.url_scheme", "HTTP_VERSION", "REQUEST_PATH", "action_dispatch.secret_token",
+        "action_dispatch.show_exceptions", "action_dispatch.remote_ip", "rack.session",
+        "rack.session_options", "rack.request.cookie_hash", "action_dispatch.request.unsigned_session_cookie",
+        "action_dispatch.request.path_parameters"]
+      self.server = {}
+      server_keys.each do |key|
+        self.server[key] = env[key].to_s
+      end      
+    end
+    
+    def assemble_url(env)
+      protocol = env["rack.url_scheme"]
+      protocol ||= "http"
+      if env["HTTP_HOST"]
+        host = env["HTTP_HOST"]
+      else
+        host = env["SERVER_NAME"]
+        unless [80, 443].include?(env["SERVER_PORT"])
+          host << ":#{env["SERVER_PORT"]}"
+        end
+      end
+      path = env["SCRIPT_NAME"] + env["PATH_INFO"]
+      "#{protocol}://#{host}#{path}"
+    end
+    
+    ##
+    # Extract the file name from a backtrace. Format for the first line is something like:
+    #      "/Users/user/workspace/coalmine_ruby_test/app/controllers/index_controller.rb:4:in `index'"
+    #
+    # @param  <String> backtrace The exceptions backtrace
+    # @return <String|Nil> The file name that generated the exception. This is based from the project root.
+    def extract_file_name(backtrace)
+      return unless backtrace
+      backtrace = backtrace.to_a
+      return unless backtrace.length >= 1
+      
+      m = backtrace.first.match(/^(.+?):/)
+      return unless m and m.length > 1
+      m[1].gsub(Dir.getwd, "")
+    end
+    
+    ##
+    # Extract the line number which generated the exception.
+    #
+    # @param  <String> backtrace Backtrace of the exception
+    # @return <Integer|Nil> The line number of the error. Nil if cannot be found.
+    def extract_line_number(backtrace)
+      return unless backtrace
+      backtrace = backtrace.to_a
+      return unless backtrace.length > 1
+      m = backtrace.first.match(/^.+:(\d+):/)
+      return unless m and m.length > 1
+      m[1]
+    end
+  end
+end

data/lib/coalmine/rack.rb

@@ -0,0 +1,22 @@
+module Coalmine
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => e
+        Coalmine.notify(e, :rack_env => env)
+        raise
+      end
+      
+      if env["rack.exception"]
+        Coalmine.notify(env["rack.exception"], :rack_env => env)
+      end
+      
+      response
+    end
+  end
+end

data/lib/coalmine/rails/action_controller.rb

@@ -0,0 +1,15 @@
+module Coalmine
+  module Rails
+    module ActionController
+      
+      ##
+      # Setup some rails magic so that when an exception is raised, it is
+      # first sent to our handler.
+      def self.included(base)
+        base.send(:before_filter, :clear_coalmine_custom_variables)
+        base.send(:alias_method, :rescue_action_in_public_without_coalmine, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_coalmine)
+      end
+    end
+  end
+end

data/lib/coalmine/rails/controller_methods.rb

@@ -0,0 +1,57 @@
+module Coalmine
+  module Rails
+    module ControllerMethods
+      
+    protected
+
+      ##
+      # Convenience method for other developers to send information to coalmine.
+      #
+      # @param  [Hash|Exception] The exception or hash to send to Coalmine API.
+      def notify_coalmine(exception_or_hash)
+        return unless coalmine_notification_allowed?
+        Coalmine.notify(exception_or_hash, coalmine_request_data)
+      end
+      
+      def clear_coalmine_custom_variables
+        Coalmine.custom_variables.clear
+      end
+
+    private
+
+      ##
+      # Automatically called by the rails stack when an uncaught exception
+      # is encountered.
+      #
+      # @param  [Exception] The uncaught exception
+      def rescue_action_in_public_with_coalmine(exception)
+        Coalmine.logger.debug "Coalmine is handling uncaught exception: #{exception.message}"
+        notify_coalmine(exception)
+        rescue_action_in_public_without_coalmine(exception)
+      end
+
+      ##
+      # Gather environment information about the current request.
+      #
+      # @return [Hash] Information about the current request.
+      def coalmine_request_data
+        {
+          :controller => params[:controller],
+          :action     => params[:action],
+          :url        => request.url,
+          :method     => request.method,
+          :parameters => params,
+          :ip_address => request.remote_ip
+        }
+      end
+      
+      ##
+      # Determine if the we can notify coalmine.
+      #
+      # @return <Boolean> True if we can send notifications in the current env.
+      def coalmine_notification_allowed?
+        Coalmine.config.enabled_environments.include?(::Rails.env)
+      end
+    end
+  end
+end

data/lib/coalmine/rails/tasks.rb

@@ -0,0 +1,13 @@
+namespace :coalmine do
+  desc "Notify Coalmine of a recent deployment"
+  task :deployment, [:version, :author] => [:environment] do |t, args|
+    version = Coalmine::VersionNotification.new
+    version.version = args[:version]
+    version.author = args[:author]
+    if Coalmine::Sender.send(version)
+      puts "Successfully notified Coalmine of version #{args[:version]}"
+    else
+      puts "There was an error while notifying Coalmine. Please check the logs for details."
+    end
+  end
+end

data/lib/coalmine/rails.rb

@@ -0,0 +1,26 @@
+require "coalmine"
+require "coalmine/rails/action_controller"
+
+##
+# Enhance rails 2 apps with coalmine error catching. This injects some methods into
+# ActionController::Base which catches exceptions.
+module Coalmine
+  module Rails
+    def self.init
+      
+      if defined? ::ActionController::Base
+        Rails.logger.debug "Enhancing ActionController::Base with Coalmine goodies."
+        ::ActionController::Base.send(:include, Coalmine::Rails::ActionController)
+      end
+      
+      # Add to configuration
+      Coalmine.configure do |config|
+        config.logger = Rails.logger
+        config.environment = Rails.env
+        config.project_root = Rails.root
+        config.framework = "Rails: #{::Rails::VERSION::STRING}" if defined? ::RAILS::VERSION
+      end
+    end
+  end
+end
+      

data/lib/coalmine/railtie.rb

@@ -0,0 +1,31 @@
+require "coalmine"
+require "rails"
+
+module Coalmine
+  class Railtie < Rails::Railtie
+    
+    initializer "coalmine.use_rack_middleware" do |app|
+      app.config.middleware.use "Coalmine::Rack"
+    end
+
+    rake_tasks do
+      load "coalmine/rails/tasks.rb"
+    end
+    
+    config.after_initialize do
+      # Add to configuration
+      Coalmine.configure do |config|
+        config.logger = Rails.logger
+        config.environment ||= Rails.env
+        config.project_root ||= Rails.root
+        config.framework ||= "Rails: #{::Rails::VERSION::STRING}" if defined? ::RAILS::VERSION
+        config.filters += Rails.application.config.filter_parameters
+      end
+      
+      if defined? ::ActionController::Base
+         require "coalmine/rails/controller_methods"
+          ::ActionController::Base.send(:include, Coalmine::Rails::ControllerMethods)
+      end
+    end
+  end
+end

data/lib/coalmine/sender.rb

@@ -0,0 +1,78 @@
+require "net/http"
+require "net/https"
+require "cgi"
+
+module Coalmine
+  class Sender
+    
+    HEADERS = {
+      "Content-type" => "application/x-www-form-urlencoded",
+      "Accept"       => "text/json, application/json"
+    }
+      
+    HTTP_ERRORS = [Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, 
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, 
+      Errno::ECONNREFUSED, Errno::ETIMEDOUT].freeze
+    
+    def self.send(notification)
+      unless config.enabled_environments.include?(config.environment)
+        Coalmine.logger.debug "Attempted to send a notification to Coalmine, " +
+            "but notifications are not enabled for #{config.environment}. To " +
+            "send requests for this environment, add it to config.enabled_environments."
+        return
+      end
+      
+      proxy = Net::HTTP::Proxy(config.proxy_host, config.proxy_port, config.proxy_user, config.proxy_password)
+      url = self.url(notification)
+      http = proxy.new(url.host, url.port)
+      
+      http.read_timeout = config.http_read_timeout
+      http.open_timeout = config.http_open_timeout
+
+      if config.secure?
+        http.use_ssl     = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file     = OpenSSL::X509::DEFAULT_CERT_FILE if File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+      else
+        http.use_ssl     = false
+      end
+
+      response = nil
+      begin
+        req = Net::HTTP::Post.new(url.path)
+        req.set_form_data(notification.post_data)
+        HEADERS.each_pair do |key, value|
+          req[key] = value
+        end
+        
+        if config.http_user && config.http_password
+          req.basic_auth config.http_user, config.http_password
+        end
+        
+        response = http.request(req)
+        
+        unless response.code == "200"
+          Coalmine.logger.error "Unable to notify Coalmine (HTTP #{response.code})"
+          Coalmine.logger.error "Coalmine response: #{response.body}" if response.body
+          return false
+        end
+      rescue *HTTP_ERRORS => e
+        Coalmine.logger.error "Timeout while attempting to notify Coalmine at #{url}"
+        return false
+      end
+      
+      Coalmine.logger.debug "Sent notification to Coalmine at #{url}"
+      true
+    end
+
+protected
+
+    def self.url(data)
+      URI.parse("#{config.protocol}://#{config.host}:#{config.port}#{data.resource_path}")
+    end
+    
+    def self.config
+      Coalmine.config
+    end
+  end
+end

data/lib/coalmine/version.rb

@@ -0,0 +1,3 @@
+module Coalmine
+  VERSION = "0.5.0"
+end

data/lib/coalmine/version_notification.rb

@@ -0,0 +1,19 @@
+module Coalmine
+  class VersionNotification
+    
+    attr_accessor :environment, :version, :author
+    
+    def initialize
+      self.environment = Coalmine.config.environment
+    end
+    
+    def resource_path
+      "/versions/"
+    end
+    
+    def post_data
+      {:signature => Coalmine.config.signature, :environment => self.environment, 
+        :version => self.version, :author => self.author}
+    end
+  end
+end

data/lib/coalmine.rb

@@ -0,0 +1,101 @@
+require "coalmine/configuration"
+require "coalmine/sender"
+require "coalmine/notification"
+require "coalmine/rack"
+require "coalmine/logger"
+require "coalmine/version_notification"
+require "coalmine/railtie" if defined? Rails
+
+module Coalmine
+  
+  ##
+  # Configure the coalmine client.
+  # 
+  # @example
+  #   Coalmine.configure do |config|
+  #     config.signature = "abc"
+  #     config.logger = Rails.logger
+  #   end
+  def self.configure
+    yield(config)
+  end
+  
+  ##
+  # Fetch the config.
+  #
+  # @return [Coalmine::Configuration] The configuration
+  def self.config
+    @configuration ||= Configuration.new
+    @configuration
+  end
+  
+  def self.logger
+    config.logger
+  end
+  
+  ##
+  # Send an exception manually to the API. This method packages up the exception and
+  # then sends it.
+  #
+  # @param  [Exception] exception The exception to log
+  # @return [Boolean] True if notification is sent OK
+  def self.notify(exception, additional_data = {})
+    
+    # We also log the exception locally.
+    logger.error exception
+
+    # Be paranoid about causing exceptions.
+    begin
+      notification = build_from_exception(exception, additional_data)
+      
+      # Send the exception to the remote.
+      return send(notification)
+    rescue Exception => e
+      logger.error e
+      return false
+    end
+  end
+  
+  def self.err(message)
+    notify(nil, :message => message, :severity => "ERROR")
+  end
+  
+  def self.error(message)
+    err(message)
+  end
+  
+  def self.warn(message)
+    notify(nil, :message => message, :severity => "WARN")
+  end
+  
+  def self.info(message)
+    notify(nil, :message => message, :severity => "INFO")
+  end
+  
+  def self.debug(message)
+    notify(nil, :message => message, :severity => "DEBUG")
+  end
+  
+  def self.filter(hash)
+    @filter ||= ActionDispatch::Http::ParameterFilter.new(config.filters)
+    @filter.filter(hash)
+  end
+  
+  ##
+  # Variables that may be set by the application.
+  def self.custom_variables
+    @custom_variables ||= {}
+  end
+  
+protected
+
+  def self.build_from_exception(exception, additional_data = {})
+    additional_data ||= {}
+    additional_data[:exception] = exception
+    Notification.new(additional_data)
+  end
+  
+  def self.send(data)
+    Coalmine::Sender.send(data)
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require "coalmine/rails"
+Coalmine::Rails.init

data/spec/coalmine/configuration_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Coalmine::Configuration do
+  
+  it "defaults to http protocol" do
+    Coalmine::Configuration.new.protocol.should == "http"
+  end
+  
+  it "falls back to http when an unsupported protocol is given" do
+    config = Coalmine::Configuration.new
+    config.protocol = "something"
+    config.protocol.should == "http"
+  end
+  
+  it "accepts https as the protocol" do
+    config = Coalmine::Configuration.new
+    config.protocol = "https"
+    config.protocol.should == "https"
+  end
+  
+  it "sets appropriate timeout defaults" do
+    config = Coalmine::Configuration.new
+    config.http_read_timeout.should_not be_nil
+    config.http_read_timeout.should > 0
+    config.http_open_timeout.should_not be_nil
+    config.http_open_timeout.should > 0
+  end
+end

data/spec/coalmine/notification_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+describe Coalmine::Notification do
+
+  it "grabs info from the exception" do
+    exception = Exception.new("a test exception")
+    notification = Coalmine::Notification.new(:exception => exception)
+    notification.message.should == exception.message
+    notification.stack_trace.should == exception.backtrace
+    notification.error_class.should == exception.class.name
+  end
+  
+  it "serializes to json" do
+    exception = Exception.new("just a test")
+    notification = Coalmine::Notification.new(:exception => exception, :url => "http://www.test.com", :user_agent => %Q[something "with" quote's])
+    json = ActiveSupport::JSON.decode(notification.to_json)
+    
+    required_fields = ["signature", "version", "app_environment", "url"]
+    required_fields.each do |field|
+      json.keys.include?(field)
+    end
+  end
+  
+  it "sets the file name" do
+    begin
+      raise Exception.new("test")
+    rescue Exception => e
+      notification =  Coalmine::Notification.new(:exception => e)
+      notification.file.should_not be_nil
+    end
+  end
+  
+  it "sets the line number" do
+    begin
+      raise Exception.new("test")
+    rescue Exception => e
+      notification = Coalmine::Notification.new(:exception => e)
+      notification.line_number.should_not be_nil
+    end
+  end
+  
+  it "populates from a rack env" do
+    url = "http://localhost:3000/"
+    ip = "123.3.32.234"
+    method = "GET"
+    params = "key=value&some_other_key=*another(val)"
+    user_agent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.220 Safari/535.1"
+    cookies = "_coalmine_session=BAh7B0kiD3Nlc3Npb25faWQGOgZFRkkiJTZiZTE3NWZiNDMzNWE4NTZiNGUyOTllODkzYzQwMDk5BjsAVEkiEF9jc3JmX3Rva2VuBjsARkkiMUJaaE1pWWdnWTkwalg3ZmZTWVZKbE5GU3d4UzhJcEtJWTF2cGxmanViWEk9BjsARg%3D%3D--7ef48133c020462203c902444fe11fa8241f9c02"
+    
+    rack_env = {"GATEWAY_INTERFACE" => "CGI/1.1", "PATH_INFO" => "/", "QUERY_STRING" => params, 
+      "REMOTE_ADDR" => ip, "REMOTE_HOST" => "localhost", "REQUEST_METHOD" => method, 
+      "REQUEST_URI" => url, "SCRIPT_NAME"=>"", "SERVER_NAME"=>"localhost", "SERVER_PORT"=>"3000", 
+      "SERVER_PROTOCOL"=>"HTTP/1.1", "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.2/2011-07-09)", 
+      "HTTP_HOST"=>"localhost:3000", "HTTP_CONNECTION"=>"keep-alive", 
+      "HTTP_USER_AGENT"=> user_agent, "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch", "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8", 
+      "HTTP_ACCEPT_CHARSET"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.3", 
+      "HTTP_COOKIE"=> cookies, "rack.version"=>[1, 1]}
+
+    notification = Coalmine::Notification.new(:rack_env => rack_env)
+    notification.url.should == url
+    notification.ip_address.should == ip
+    notification.method.should == method
+    notification.user_agent.should == user_agent
+    notification.cookies.should == cookies
+    notification.parameters.should == params
+    notification.environment.length.should >= 20
+  end
+  
+  it "defaults to error severity" do
+    notification = Coalmine::Notification.new
+    notification.severity.should == "ERROR"
+  end
+  
+  it "allows severity to be set explicitly" do
+    severity = "INFO"
+    notification = Coalmine::Notification.new(:severity => severity)
+    notification.severity.should == severity
+  end
+  
+  it "sets the hostname" do
+    notification = Coalmine::Notification.new
+    notification.hostname.should_not be_nil
+  end
+  
+  it "does not allow hostname to be set explicitly" do
+    hostname = "not a real hostname"
+    notification = Coalmine::Notification.new(:hostname => hostname)
+    notification.hostname.should_not == hostname
+  end
+  
+  it "sets the process ID" do
+    notification = Coalmine::Notification.new
+    notification.process_id.should_not be_nil
+  end
+  
+  it "does not allow the process ID to be set explicitly" do
+    pid = 1
+    notification = Coalmine::Notification.new(:process_id => pid)
+    notification.process_id.should_not == pid
+  end
+  
+  it "sets the thread ID" do
+    notification = Coalmine::Notification.new
+    notification.thread_id.should_not be_nil
+    notification.thread_id.should > 0
+  end
+  
+  it "does not allow the thread ID to be set explicitly" do
+    thread_id = 1
+    notification = Coalmine::Notification.new(:thread_id => thread_id)
+    notification.thread_id.should_not == thread_id
+    notification.thread_id.should_not be_nil
+  end
+end

data/spec/coalmine/sender_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Coalmine::Sender do
+  
+  before :each do
+    FakeWeb.clean_registry
+    Coalmine.configure do |config|
+      config.signature = "test"
+    end
+  end
+  
+  context "sending data" do
+    it "successfully sends data given the happy path" do
+      FakeWeb.register_uri(:post, Coalmine::Sender.url, :status => "200")
+      Coalmine::Sender.send("some test data").should be_true
+    end
+    
+    it "successfully sends data through a proxy" do
+      Coalmine.configure do |config|
+        config.proxy_host = "coalmine-proxy.net"
+        config.proxy_port = 999
+        config.proxy_user = "some_user"
+        config.proxy_password = "Sp3c!@lCh4r#"
+      end
+      
+      FakeWeb.register_uri(:post, Coalmine::Sender.url, :status => "200")
+      Coalmine::Sender.send("something").should be_true
+    end
+    
+    it "fails when response code is bad" do
+      FakeWeb.register_uri(:post, Coalmine::Sender.url, :status => ["500", "Internal Server Error"])
+      Coalmine::Sender.send("test data").should be_false
+    end
+    
+    it "catches network errors" do
+      Net::HTTP.any_instance.stub(:post).and_raise(Timeout::Error)
+      Coalmine::Sender.send("test").should be_false
+    end
+  end
+end

data/spec/coalmine_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Coalmine do
+  
+  context "configuring" do
+    it "allows block style configuration" do
+      host = "http://www.test.com"
+      port = 3000
+      Coalmine.configure do |config|
+        config.host = host
+        config.port = port
+      end
+      
+      Coalmine.config.host.should == host
+      Coalmine.config.port.should == port
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "coalmine"
+require "fakeweb"
+
+FakeWeb.allow_net_connect = false

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: coalmine
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Brad Seefeld
+- Matt Ratzloff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jsonbuilder
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Send errors to the Coalmine API for logging and analytics.
+email: 
+- admin@coalmineapp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- coalmine.gemspec
+- lib/coalmine.rb
+- lib/coalmine/capistrano.rb
+- lib/coalmine/configuration.rb
+- lib/coalmine/logger.rb
+- lib/coalmine/notification.rb
+- lib/coalmine/rack.rb
+- lib/coalmine/rails.rb
+- lib/coalmine/rails/action_controller.rb
+- lib/coalmine/rails/controller_methods.rb
+- lib/coalmine/rails/tasks.rb
+- lib/coalmine/railtie.rb
+- lib/coalmine/sender.rb
+- lib/coalmine/version.rb
+- lib/coalmine/version_notification.rb
+- rails/init.rb
+- spec/coalmine/configuration_spec.rb
+- spec/coalmine/notification_spec.rb
+- spec/coalmine/sender_spec.rb
+- spec/coalmine_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/coalmine/coalmine_ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: coalmine
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Coalmine Connector Ruby implementation
+test_files: 
+- spec/coalmine/configuration_spec.rb
+- spec/coalmine/notification_spec.rb
+- spec/coalmine/sender_spec.rb
+- spec/coalmine_spec.rb
+- spec/spec_helper.rb