errordite 0.0.1

data/examples/rails/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-agent: *
+# Disallow: /

data/lib/errordite-rails.rb

@@ -0,0 +1,7 @@
+require 'errordite'
+
+class Errordite::Railtie < Rails::Railtie
+  initializer "errordite.middleware" do |app|
+    app.config.middleware.insert 0, "Errordite::Rack"
+  end
+end

data/lib/errordite.rb

@@ -0,0 +1,33 @@
+require 'errordite/version'
+
+module Errordite
+  autoload :Client, 'errordite/client'
+  autoload :Config, 'errordite/config'
+  autoload :Rack, 'errordite/rack'
+  autoload :Serializer, 'errordite/serializer'
+
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def config=(config)
+      @config = config
+    end
+
+    def method_missing(method, *args)
+      if config.respond_to?(method)
+        config.__send__ method, *args
+      else
+        super
+      end
+    end
+
+    def monitor(context = {})
+      yield
+    rescue Exception => e
+      client.record e, context
+      raise e
+    end
+  end
+end

data/lib/errordite/client.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+
+class Errordite::Client
+  attr_reader :server, :port, :logger
+
+  def initialize(server = 'www.errordite.com', port = 443, logger = Errordite.logger)
+    @server = server
+    @port = port
+    @logger = logger
+  end
+
+  def record(error, context)
+    post_json '/receiveerror', Errordite::Serializer.new(error, context).to_json
+  end
+
+  def post_json(path, body)
+    headers = {'Content-Type' => 'application/json; charset=utf-8', 'Content-Length' => body.size.to_s}
+    response = Connection.new(server, port).post path, body, headers
+    log_response response
+    response
+  end
+
+  private
+
+  def log_response(response)
+    if response.code != "201"
+      logger.warn "Failed to log error: #{response.code} #{response.message}"
+    elsif logger.debug?
+      logger.debug "Error logged: #{response.code} #{response.message}"
+    end
+  end
+
+  class Connection
+    def initialize(server, port)
+      @http = Net::HTTP.new server, port
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    def post(*args)
+      @http.post(*args)
+    end
+  end
+end

data/lib/errordite/config.rb

@@ -0,0 +1,44 @@
+require 'errordite'
+require 'logger'
+
+class Errordite::Config
+  def api_token
+    @api_token ||= ENV['ERRORDITE_TOKEN']
+  end
+
+  def api_token=(token)
+    @api_token = token
+  end
+
+  def server
+    @server ||= 'www.errordite.com'
+  end
+
+  def server=(s)
+    @server = s
+  end
+
+  def port
+    @port ||= 443
+  end
+
+  def port=(p)
+    @port = p
+  end
+
+  def logger
+    @logger ||= begin
+      l = Logger.new(STDOUT)
+      l.level = Logger::WARN
+      l
+    end
+  end
+
+  def client
+    @client ||= Errordite::Client.new(server, port)
+  end
+
+  def client=(client)
+    @client = client
+  end
+end

data/lib/errordite/rack.rb

@@ -0,0 +1,22 @@
+require 'errordite'
+require 'rack/request'
+
+class Errordite::Rack
+  def initialize(app, options = {})
+    @app = app
+    @context = options[:context] || {}
+  end
+
+  def call(env)
+    Errordite.monitor rack_context(env).merge(@context) do
+      @app.call(env)
+    end
+  end
+
+  private
+
+  def rack_context(env)
+    request = Rack::Request.new(env)
+    {'Url' => request.url, 'UserAgent' => env['HTTP_USER_AGENT']}
+  end
+end

data/lib/errordite/serializer.rb

@@ -0,0 +1,62 @@
+require 'errordite'
+require 'json'
+
+class Errordite::Serializer
+  SPECIAL_CONTEXT_ATTRIBUTES = ['MachineName', 'Url', 'UserAgent', 'Version']
+
+  attr_reader :exception, :context
+
+  def initialize(exception, context = {})
+    @exception = exception
+    @context = context
+  end
+
+  def as_json
+    special_attributes.merge(
+      "Token" => Errordite.api_token,
+      "TimestampUtc" => Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+      "ExceptionInfo" => {
+        "Source" => source,
+        "Message" => exception.message,
+        "MethodName" => method_name,
+        "ExceptionType" => exception.class.name,
+        "StackTrace" => stack_trace,
+        "Data" => exception_data
+      }
+    )
+  end
+
+  def to_json
+    JSON.dump(as_json)
+  end
+
+  private
+
+  def special_attributes
+    Hash[context.select {|k, v| SPECIAL_CONTEXT_ATTRIBUTES.include?(k) }]
+  end
+
+  def exception_data
+    Hash[context.reject {|k, v| SPECIAL_CONTEXT_ATTRIBUTES.include?(k) }]
+  end
+
+  def timestamp
+    Time.now.strftime("%Y-%m-%d %H:%M:%S")
+  end
+
+  def stack_trace
+    exception.backtrace && exception.backtrace.join("\n")
+  end
+
+  def source
+    split_first_line && split_first_line[1]
+  end
+
+  def method_name
+    split_first_line && split_first_line[3]
+  end
+
+  def split_first_line
+    @split_first_line ||= exception.backtrace && exception.backtrace[0] && exception.backtrace[0].match(/^(.*?)(?:\:(\d+))(?:\:in `(.*)')?$/)
+  end
+end

data/lib/errordite/version.rb

@@ -0,0 +1,3 @@
+module Errordite
+  VERSION = "0.0.1"
+end

data/spec/lib/errordite/client_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Errordite::Client do
+  let(:logger) { double(:logger) }
+  let(:connection) { double(:connection) }
+  let(:response) { double(:response, code: '201', message: 'Created') }
+
+  before :each do
+    Errordite::Client::Connection.stub(:new).and_return(connection)
+    connection.stub(:post).and_return(response)
+  end
+
+  it 'records errors by posting them to /receiveerror' do
+    error = double(:error)
+    context = double(:context)
+    serializer = double(:serializer, to_json: 'json-representation')
+    Errordite::Serializer.stub(:new).with(error, context).and_return(serializer)
+    subject.should_receive(:post_json).with('/receiveerror', 'json-representation')
+    subject.record(error, context)
+  end
+
+  it 'sends json to the server by posting through a new connection' do
+    path = '/receiveerror'
+    body = '{}'
+    connection.should_receive(:post).with(
+      '/receiveerror', '{}', 'Content-Type' => 'application/json; charset=utf-8', 'Content-Length' => '2'
+    ).and_return(response)
+    Errordite::Client.new.post_json(path, body)
+  end
+
+  it 'logs response if code != 201' do
+    client = Errordite::Client.new('server.example.com', 443, logger)
+    response.stub(:code).and_return('500')
+    response.stub(:message).and_return('Server Error')
+    logger.should_receive(:warn)
+    client.post_json '/receiveerror', ''
+  end
+
+  it 'logs response if log level is debug' do
+    client = Errordite::Client.new('server.example.com', 443, logger)
+    response.stub(:code).and_return('500')
+    response.stub(:message).and_return('Server Error')
+    logger.should_receive(:warn)
+    client.post_json '/receiveerror', ''
+  end
+end
+
+describe Errordite::Client::Connection do
+  let(:http) { double(:http).as_null_object }
+
+  it 'creates a new verified https connection to the given server and port' do
+    Net::HTTP.stub(:new).with('one.example.com', 443).and_return(http)
+    http.should_receive(:use_ssl=).with(true)
+    http.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+    Errordite::Client::Connection.new('one.example.com', 443)
+  end
+
+  it 'posts data through the https connection' do
+    Net::HTTP.stub(:new).and_return(http)
+    arguments = double('arguments')
+    http.should_receive(:post).with(arguments)
+    Errordite::Client::Connection.new('one.example.com', 443).post(arguments)
+  end
+end

data/spec/lib/errordite/config_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Errordite::Config do
+  subject { Errordite::Config.new }
+  let(:client) { double('client') }
+
+  it 'uses www.errordite.com as default server' do
+    expect(subject.server).to eql('www.errordite.com')
+  end
+
+  it 'allows server to be set' do
+    subject.server = 'errordite.example.com'
+    expect(subject.server).to eql('errordite.example.com')
+  end
+
+  it 'uses 443 as default port' do
+    expect(subject.port).to eql(443)
+  end
+
+  it 'allows port to be set' do
+    subject.port = 80
+    expect(subject.port).to eql(80)
+  end
+
+  it 'uses ERRORDITE_TOKEN environment variable as default api token' do
+    ENV['ERRORDITE_TOKEN'] = 'token-from-environment'
+    expect(subject.api_token).to eql('token-from-environment')
+  end
+
+  it 'allows api token to be set' do
+    ENV['ERRORDITE_TOKEN'] = 'token-from-environment'
+    subject.api_token = 'overidden-token'
+    expect(subject.api_token).to eql('overidden-token')
+  end
+
+  it 'logs to STDOUT with log level of WARN by default' do
+    logger = double('logger')
+    Logger.should_receive(:new).with(STDOUT).and_return(logger)
+    logger.should_receive(:level=).with(Logger::WARN)
+    expect(subject.logger).to eql(logger)
+  end
+
+  it 'builds client with server and port' do
+    subject.server = 'errordite.example.com'
+    subject.port = 123
+    Errordite::Client.should_receive(:new).with('errordite.example.com', 123).and_return(client)
+    expect(subject.client).to eql(client)
+  end
+
+  it 'memoizes client' do
+    Errordite::Client.stub(:new).and_return(client)
+    expect(subject.client).to eql(client)
+    expect(subject.client).to eql(client)
+  end
+
+  it 'allows custom client to be set' do
+    custom_client = double('custom-client')
+    subject.client = custom_client
+    expect(subject.client).to eql(custom_client)
+  end
+end

data/spec/lib/errordite/serializer_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Errordite::Serializer do
+  describe '(in general)' do
+    let(:context) { Hash.new }
+    let(:exception) { Exception.new }
+    let(:serializer) { Errordite::Serializer.new(exception, context) }
+
+    it 'includes Token taken from Errordite.api_token' do
+      Errordite.stub(:api_token).and_return("AnApiToken")
+      expect(serializer.as_json['Token']).to eql('AnApiToken')
+    end
+
+    it 'takes TimestampUtc from the current time' do
+      Time.stub(:now).and_return(Time.utc(2013, 3, 4, 12, 34, 56))
+      expect(serializer.as_json['TimestampUtc']).to eql('2013-03-04 12:34:56')
+    end
+
+    it 'takes Source from backtrace file' do
+      exception.stub(:backtrace).and_return(["/path/to/file/example.rb:80:in `hello'"])
+      expect(serializer.as_json['ExceptionInfo']['Source']).to eql('/path/to/file/example.rb')
+    end
+
+    it 'takes MethodName from backtrace method' do
+      exception.stub(:backtrace).and_return(["/path/to/file/example.rb:80:in `hello'"])
+      expect(serializer.as_json['ExceptionInfo']['MethodName']).to eql('hello')
+    end
+
+    it 'takes ExceptionType from exception class' do
+      exception.stub(:class).and_return(FloatDomainError)
+      expect(serializer.as_json['ExceptionInfo']['ExceptionType']).to eql('FloatDomainError')
+    end
+
+    it 'takes Message from exception message' do
+      exception.stub(:message).and_return("My message is this")
+      expect(serializer.as_json['ExceptionInfo']['Message']).to eql('My message is this')
+    end
+
+    ['MachineName', 'Url', 'UserAgent', 'Version'].each do |special_attribute|
+      it "adds #{special_attribute} to top level if included in context" do
+        context[special_attribute] = "special-attribute-value"
+        expect(serializer.as_json[special_attribute]).to eql("special-attribute-value")
+      end
+    end
+
+    it "adds other unknown attributes to exception data when included in context" do
+      context["Anything"] = "anything-value"
+      context["Something"] = "something-value"
+      expect(serializer.as_json["ExceptionInfo"]["Data"]).to eql({
+        "Anything" => "anything-value",
+        "Something" => "something-value"
+      })
+    end
+
+    it 'forms StackTrace using backtrace joined with newlines' do
+      exception.stub(:backtrace).and_return(["first-line", "second-line"])
+      expect(serializer.as_json['ExceptionInfo']['StackTrace']).to eql("first-line\nsecond-line")
+    end
+
+    it 'is serializable as JSON' do
+      serializer.stub(:as_json).and_return(:as_json_result)
+      JSON.should_receive(:dump).with(:as_json_result).and_return(:serialized_json)
+      expect(serializer.to_json).to eql(:serialized_json)
+    end
+  end
+end

data/spec/lib/errordite_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Errordite do
+  let(:config) { double('config') }
+
+  before :each do
+    Errordite.config = nil
+    Errordite::Config.stub(:new).and_return(config)
+  end
+
+  it 'builds a new Config instance if none set' do
+    Errordite::Config.should_receive(:new).and_return(config)
+    expect(Errordite.config).to eql(config)
+  end
+
+  it 'returns same Config instance if asked multiple times' do
+    expect(Errordite.config).to equal(Errordite.config)
+  end
+
+  [:api_token].each do |method|
+    it "delegates getting #{method} to config instance" do
+      result = double('result')
+      config.should_receive(method).and_return(result)
+      expect(Errordite.__send__(method)).to equal(result)
+    end
+
+    it "delegates setting #{method} to config instance" do
+      argument = double('argument')
+      result = double('result')
+      config.should_receive("#{method}=").with(argument).and_return(result)
+      expect(Errordite.__send__("#{method}=", argument)).to equal(result)
+    end
+  end
+end