sfalma 0.7

data/lib/sfalma/integration/tester.rb

@@ -0,0 +1,20 @@
+module Sfalma
+  module Integration
+    class SfalmaTestException <StandardError;
+    end
+
+    def self.test
+      begin
+        raise SfalmaTestException.new, 'Test exception from Rails'
+      rescue Exception => e
+        unless Sfalma::Remote.error(Sfalma::ExceptionData.new(e, "Test Exception"))
+          puts "Problem sending exception to Sfalma. Check your API key."
+        else
+          puts "We got one! Head to http://www.sfalma.com/login to see the error!"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/sfalma/log_factory.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Sfalma
+  class LogFactory
+    def self.logger
+      @logger ||= create_logger_with_fallback
+    end
+
+    private
+    def self.create_logger_with_fallback
+      begin
+        log_dir = File.join(Config.application_root, 'log')
+        Dir.mkdir(log_dir) unless File.directory?(log_dir)
+        log_path = File.join(log_dir, "/sfalma.log")
+        log = Logger.new(log_path)
+        log.level = Logger::INFO
+        def log.format_message(severity, timestamp, progname, msg)
+          "[#{severity.upcase}] (#{[Kernel.caller[2].split('/').last]}) #{timestamp.utc.to_s} - #{msg2str(msg).gsub(/\n/, '').lstrip}\n"
+        end
+        def log.msg2str(msg)
+          case msg
+            when ::String
+              msg
+            when ::Exception
+              "#{ msg.message } (#{ msg.class }): " <<
+                (msg.backtrace || []).join(" | ")
+            else
+              msg.inspect
+          end
+        end
+        log
+      rescue
+        return Rails.logger if defined?(Rails) && defined?(Rails.logger)
+        return RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)
+        return Logger.new(STDERR)
+      end
+    end
+  end
+end

data/lib/sfalma/monkeypatches.rb

@@ -0,0 +1,10 @@
+class Regexp
+  def to_json(options = {})
+    "\"#{self.to_s}\""
+  end
+end
+class Fixnum
+  def to_json(options = {})
+    to_s
+  end
+end

data/lib/sfalma/rack_exception_data.rb

@@ -0,0 +1,29 @@
+require 'digest/md5'
+
+module Sfalma
+  class RackExceptionData < ExceptionData
+    def initialize(exception, environment, request)
+      super(exception)                  
+      @environment = environment
+      @request = request
+    end
+
+    def framework
+      "rack"
+    end
+
+    def extra_stuff
+      return {} if @request.nil?
+      {
+        'request' => {
+          'url' => "#{@request.url}",                       
+          'parameters' => @request.params,
+          'request_method' => @request.request_method.to_s,
+          'remote_ip' => @request.ip,
+          'headers' => extract_http_headers(@environment),
+          'session' => self.class.sanitize_session(@request)
+        }
+      }
+    end
+  end
+end

data/lib/sfalma/railtie.rb

@@ -0,0 +1,20 @@
+require 'sfalma'
+require 'rails'
+
+module Sfalma
+  class Railtie < Rails::Railtie
+
+    initializer "sfalma.middleware" do |app|
+
+      config_file = File.join(Rails.root, "/config/sfalma.yml")
+      Sfalma::Config.load config_file if File.exist?(config_file)
+      # On Heroku config is loaded via the ENV so no need to load it from the file
+
+      if Sfalma::Config.should_send_to_api?
+        Sfalma.logger.info("Loading Sfalma #{Sfalma::VERSION} for #{Rails::VERSION::STRING}")
+        app.config.middleware.use "Rack::RailsSfalma"
+        Sfalma::Startup.announce
+      end
+    end
+  end
+end

data/lib/sfalma/remote.rb

@@ -0,0 +1,59 @@
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'digest/md5'
+require 'uri'
+
+module Sfalma
+  class Remote
+    class << self
+      def startup_announce(startup_data)
+        data = startup_data.to_json
+        hash_param = "&hash=#{Digest::MD5.new(data).hexdigest}"
+        url = "/api/announcements?protocol_version=#{::Sfalma::PROTOCOL_VERSION}#{hash_param}"
+        call_remote(url, data)
+      end
+
+      def error(exception_data)
+        uniqueness_hash = exception_data.uniqueness_hash
+        #require 'net/http'
+        #require 'uri'
+        #Net::HTTP.post_form(URI.parse('http://www.postbin.org/pelg4f'), {:data=> exception_data.to_json})
+        hash_param = uniqueness_hash.nil? ? nil: "&hash=#{uniqueness_hash}"
+        url = "/api/errors?protocol_version=#{::Sfalma::PROTOCOL_VERSION}#{hash_param}"
+        call_remote(url, exception_data.to_json)
+      end
+
+      def call_remote(url, data)
+        config = Sfalma::Config
+        optional_proxy = Net::HTTP::Proxy(config.http_proxy_host,
+                                          config.http_proxy_port,
+                                          config.http_proxy_username,
+                                          config.http_proxy_password)
+        client = optional_proxy.new(config.remote_host, config.remote_port)
+
+        client.open_timeout = config.http_open_timeout
+        client.read_timeout = config.http_read_timeout
+        client.use_ssl = config.ssl?
+        client.verify_mode = OpenSSL::SSL::VERIFY_NONE if config.ssl?
+        begin
+          headers = { "X-Sfalma-Api-Key" => ::Sfalma::Config.api_key }
+          data.gsub!('&','@@@')
+          response = client.post(url, "data=#{data}", headers)
+          case response
+            when Net::HTTPSuccess
+              Sfalma.logger.info( "#{url} - #{response.message}")
+              return true
+            else
+              Sfalma.logger.error("#{url} - #{response.code} - #{response.message}")
+          end
+        rescue Exception => e
+          Sfalma.logger.error('Problem notifying Sfalma about the error')
+          Sfalma.logger.error('You should better send us an email')
+          Sfalma.logger.error(e)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/sfalma/startup.rb

@@ -0,0 +1,14 @@
+module Sfalma
+  class StartupException < StandardError;
+  end
+  class Startup
+    class << self
+      def announce
+        if Config.api_key.blank?
+          raise StartupException, 'API Key must be configured (/config/sfalma.yml)'
+        end
+        Remote.startup_announce(::Sfalma::ApplicationEnvironment.to_hash('rails'))
+      end
+    end
+  end
+end

data/lib/sfalma/vcs.rb

@@ -0,0 +1,45 @@
+# If you read the source code you do the right thing! Read code and reach mastery!
+# If you wonder what this is be prepared for a very neat feature! More to come soon!
+module Sfalma
+  class VCS
+    def init
+    end
+    
+    def to_hash
+      vcs = Sfalma::vcs
+      if vcs.size > 1
+        return {}
+      else
+        return {
+          'vcs' => {
+            'type' => Sfalma::vcs
+          }
+        }
+      end
+    end
+    
+    def blame(filename)
+    end
+    
+    def git(filename)
+    end
+    
+    def hg(filename)
+    end
+    
+    def svn(filename)
+    end
+    
+  end
+end
+
+# 55b250f03f1ec3c83679f9f9a158cbe1da3c9796 7 12 1
+# author Panagiotis Papadopoulos
+# author-mail <panosjee@gmail.com>
+# author-time 1294941201
+# author-tz +0200
+# committer Panagiotis Papadopoulos
+# committer-mail <panosjee@gmail.com>
+# committer-time 1294941201
+# committer-tz +0200
+# summary first commit

data/lib/sfalma/version.rb

@@ -0,0 +1,3 @@
+module Sfalma
+  VERSION = '0.7'
+end

data/lib/sfalma.rb

@@ -0,0 +1,71 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'sfalma/monkeypatches'
+require 'sfalma/catcher'
+require 'sfalma/startup'
+require 'sfalma/log_factory'
+require 'sfalma/config'
+require 'sfalma/application_environment'
+require 'sfalma/exception_data'
+require 'sfalma/controller_exception_data'
+require 'sfalma/rack_exception_data'
+require 'sfalma/alert_data'
+require 'sfalma/remote'
+require 'sfalma/integration/rack'    
+require 'sfalma/integration/rack_rails'
+require 'sfalma/integration/alerter'
+require 'sfalma/version'
+require 'sfalma/vcs'
+
+require 'sfalma/railtie' if defined?(Rails::Railtie)
+
+module Sfalma
+  PROTOCOL_VERSION = 1
+  CLIENT_NAME = 'sfalma-gem'
+  ENVIRONMENT_FILTER = []
+
+  def self.logger
+    ::Sfalma::LogFactory.logger
+  end
+
+  def self.configure(api_key)
+    Sfalma::Config.api_key = api_key
+  end
+
+  def self.handle(exception, name=nil)
+    Sfalma::Catcher.handle(exception, name)
+  end
+  
+  def self.rescue(name=nil, context=nil, &block)
+    begin
+      self.context(context) unless context.nil?
+      block.call
+    rescue Exception => e
+      Sfalma::Catcher.handle(e,name)
+    ensure
+      self.clear!
+    end
+  end
+
+  def self.rescue_and_reraise(name=nil, context=nil, &block)
+    begin
+      self.context(context) unless context.nil?
+      block.call
+    rescue Exception => e
+      Sfalma::Catcher.handle(e,name)
+      raise(e)
+    ensure
+      self.clear!      
+    end
+  end
+
+  def self.clear!
+    Thread.current[:sfalma_context] = nil
+  end
+
+  def self.context(hash = {})
+    Thread.current[:sfalma_context] ||= {}
+    Thread.current[:sfalma_context].merge!(hash)
+    self
+  end
+end

data/lib/tasks/sfalma_tasks.rake

@@ -0,0 +1,11 @@
+namespace :sfalma do
+  desc 'Send a test exception to Sfalma.'
+  task :test => :environment do
+    unless Sfalma::Config.api_key.blank?
+      puts "Sending test exception to Sfalma."
+      require "sfalma/integration/tester"
+      Sfalma::Integration.test
+      puts "Done. You can sleep in peace."
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__) , '../init.rb')

data/sfalma.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sfalma/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = %q{sfalma}
+  gem.version = Sfalma::VERSION
+  gem.authors = ["Sfalma"]
+  gem.summary = %q{ sfalma.com is a cloud-based error tracker with a social twist with a focus on mobile apps }
+  gem.description = %q{Sfalma is the Ruby gem for communicating with http://sfalma.com (hosted error tracking service). Use it to find out about errors that happen in your web or mobile app. }
+  gem.email = %q{info@sfalma.com}
+  gem.files =  Dir['lib/**/*'] + Dir['spec/**/*'] + Dir['spec/**/*'] + Dir['rails/**/*'] + Dir['tasks/**/*'] + Dir['*.rb'] + ["sfalma.gemspec"]
+  gem.homepage = %q{http://sfalma.com/}
+  gem.require_paths = ["lib"]
+  gem.executables << 'sfalma'
+  gem.rubyforge_project = %q{sfalma}
+  gem.requirements << "json_pure, json-jruby or json gem required"
+  gem.add_dependency 'rack'
+end

data/spec/bin/ginger

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'ginger'
+rescue LoadError
+  puts <<-INSTALL_GINGER
+Install ginger to test plugin against multiple environments:
+
+ gem install ginger
+
+More details: http://github.com/freelancing-god/ginger
+  INSTALL_GINGER
+  exit 0
+end
+
+require 'rake'
+
+if ARGV.length == 0
+  puts <<-USAGE
+ginger #{Ginger::Version::String}
+Use ginger to run specs for each scenario defined. Scenarios must be set out in
+a file called ginger_scenarios.rb wherever this tool is run. Once they're
+defined, then you can run this tool and provide the rake task that would
+normally be called.
+
+Examples:
+  ginger spec
+  ginger test
+  ginger spec:models
+  USAGE
+  exit 0
+end
+
+file_path = File.join Dir.pwd, ".ginger"
+
+File.delete(file_path) if File.exists?(file_path)
+
+scenarios = Ginger::Configuration.instance.scenarios
+puts "No Ginger Scenarios defined" if scenarios.empty?
+
+scenarios.each_with_index do |scenario, index|
+  puts <<-SCENARIO
+
+-------------------
+Ginger Scenario: #{scenario.name || index+1}
+-------------------
+  SCENARIO
+
+  File.open('.ginger', 'w') { |f| f.write index.to_s }
+  system("rake #{ARGV.join(" ")}") || system("rake.bat #{ARGV.join(" ")}")
+end
+
+File.delete(file_path) if File.exists?(file_path)

data/spec/dj_integration_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module Delayed
+  class Job
+    def log_exception(exception)
+    # do nothing for now
+  end
+  def name
+    "My delayed job"
+  end
+  end
+end
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sfalma', 'integration', 'dj')
+
+describe Delayed::Job do
+  before :each do
+    @job =  Delayed::Job.new
+    @exception = StandardError.new
+  end
+  it "should handle exceptions with Sfalma" do
+    Sfalma.should_receive(:handle).with(@exception, "Delayed::Job My delayed job")
+    @job.log_exception(@exception)
+  end
+  it "should clear context" do
+    Sfalma.should_receive(:clear!)
+    @job.log_exception(@exception)
+  end
+end

data/spec/fixtures/sfalma.yml

@@ -0,0 +1,10 @@
+api-key: abc123
+ssl: true
+remote-port: 123
+remote-host: example.com
+http-proxy-host: annoying-proxy.example.com
+http-proxy-port: 1066
+http-proxy-username: bob
+http-proxy-password: jack
+http-open-timeout: 5
+http-read-timeout: 10

data/spec/fixtures/sfalma_disabled.yml

@@ -0,0 +1,4 @@
+api-key: abc123
+
+production:
+  enabled: false

data/spec/ginger_scenarios.rb

@@ -0,0 +1,33 @@
+require 'ginger'
+
+class ScenarioWithName < Ginger::Scenario
+  attr_accessor :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+def is_ruby_19?
+  RUBY_VERSION[0..2].eql?('1.9')
+end
+
+def create_scenario(version)
+  scenario = ScenarioWithName.new("Rails #{version} on ruby: #{[RUBY_VERSION, RUBY_PATCHLEVEL, RUBY_RELEASE_DATE, RUBY_PLATFORM].join(' ')}")
+  scenario[/^active_?support$/]    = version
+  scenario[/^active_?record$/]     = version
+  scenario[/^action_?pack$/]       = version
+  scenario[/^action_?controller$/] = version
+  scenario[/^rails$/] = version
+  scenario
+end
+
+Ginger.configure do |config|
+  config.aliases["active_record"] = "activerecord"
+  config.aliases["active_support"] = "activesupport"
+  config.aliases["action_controller"] = "actionpack"
+
+  config.scenarios << create_scenario("2.3.3")
+  config.scenarios << create_scenario("2.3.4")
+  config.scenarios << create_scenario("2.3.5")
+  config.scenarios << create_scenario("3.0.3")
+end

data/spec/rack_integration_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'rack/mock'
+
+class SfalmaTestError < StandardError
+end
+
+describe Rack::Sfalma do
+    
+  before(:each) do 
+    Sfalma::Config.should_receive(:load)
+    @error = SfalmaTestError.new
+    @app = lambda { |env| raise @error, 'Whoops!' }
+    @env = env = Rack::MockRequest.env_for("/foo")      
+  end
+  
+  it 're-raises errors caught in the middleware' do       
+    rr = Rack::Sfalma.new(@app)        
+    Sfalma::Catcher.should_receive(:handle_with_rack)
+    lambda { rr.call(@env)}.should raise_error(SfalmaTestError)    
+  end
+end

data/spec/rails_integration_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sfalma', 'integration', 'rails')
+
+describe Sfalma, 'version number' do
+  it "be available proramatically" do
+    Sfalma::VERSION.should =~ /\d+\.\d+\.\d+/
+  end
+end
+
+describe ActiveSupport::JSON, 'standards compliant json' do
+  it "quote keys" do
+    {:a => '123'}.to_json.gsub(/ /, '').should == '{"a":"123"}'
+  end
+end
+
+class TestingController < ActionController::Base
+  filter_parameter_logging :password, /credit_card/
+
+  def raises_something
+    raise StandardError
+  end
+end
+
+describe TestingController do
+  before :each do
+    @controller = TestingController.new
+  end
+
+  it 'handle exception with Sfalma::Catcher' do
+    Sfalma::Catcher.should_receive(:handle_with_controller).with(an_instance_of(StandardError), @controller, an_instance_of(ActionController::TestRequest))
+    send_request(:raises_something)
+  end
+
+  it "still return an error response to the user" do
+    Sfalma::Catcher.stub!(:handle_with_controller)
+    send_request(:raises_something)
+    @response.code.should == '500'
+  end
+
+  it "filters paramaters based on controller filter_parameter_logging" do
+    Sfalma::Config.stub!(:should_send_to_api?).and_return(true)
+    Sfalma::Remote.should_receive(:error) {|exception_data|
+      exception_data.to_hash['request']['parameters']['credit_card_number'].should == '[FILTERED]'
+    }
+    send_request(:raises_something, {:credit_card_number => '1234566777775453', :something_else => 'boo'})
+  end
+end
+
+if ActionController::Base.respond_to?(:rescue_from)
+  class CustomError < StandardError;
+  end
+  class TestingWithRescueFromController < ActionController::Base
+    rescue_from CustomError, :with => :custom_handler
+
+    def raises_custom_error
+      raise CustomError.new
+    end
+
+    def raises_other_error
+      raise StandardError.new
+    end
+
+    def raises_with_context
+      Sfalma.context('foo' => 'bar')
+      raise StandardError.new
+    end
+
+    def custom_handler
+      head :ok
+    end
+  end
+
+  describe TestingWithRescueFromController do
+    before :each do
+      @controller = TestingWithRescueFromController.new
+    end
+
+    it 'not handle exception with Sfalma that is dealt with by rescue_from' do
+      Sfalma::Catcher.should_not_receive(:handle_with_controller)
+      send_request(:raises_custom_error)
+    end
+    it 'handle exception with Sfalma that is not dealt with by rescue_from' do
+      Sfalma::Catcher.should_receive(:handle_with_controller)
+      send_request(:raises_other_error)
+    end
+    it "has context and clears context after request" do
+      Sfalma::Config.should_receive(:should_send_to_api?).and_return(true)
+      Sfalma::Remote.should_receive(:error) {|exception_data|
+        exception_data.to_hash['context']['foo'] == 'bar'
+      }
+      send_request(:raises_with_context)
+      Thread.current[:sfalma_context].should == nil
+    end
+  end
+end

data/spec/rails_rack_integration_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'rack/mock'
+
+class SfalmaTestError < StandardError
+end
+
+describe Rack::RailsExceptional do
+
+  class TestingController < ActionController::Base
+    filter_parameter_logging :password, /credit_card/
+
+    def raises_something
+      raise StandardError
+    end
+  end
+    
+  before(:each) do 
+    @error = SfalmaTestError.new
+    @app = lambda { |env| raise @error, 'Whoops!' }
+    @env = Rack::MockRequest.env_for("/foo")    
+    @env['action_controller.instance'] = TestingController.new    
+  end
+  
+  it 're-raises errors caught in the middleware' do       
+    rr = Rack::RailsSfalma.new(@app)
+    Sfalma::Catcher.should_receive(:handle_with_controller)
+    lambda { rr.call(@env)}.should raise_error(SfalmaTestError)    
+  end
+end

data/spec/sfalma/alert_exception_data_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sfalma::AlertData do
+  it "raises error" do
+    data = Sfalma::AlertData.new(Sfalma::Alert.new("A string"), "Alert")
+    result_json = JSON.parse(data.to_json)
+    result_json['rescue_block']['name'].should == 'Alert'
+    result_json['sfalma']['message'].should == "A string"
+    result_json['sfalma']['exception_class'] == 'Sfalma::Alert'
+  end
+end

data/spec/sfalma/catcher_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sfalma::Catcher do
+  it "should create exception_data object and send json to the api" do
+    Sfalma::Config.should_receive(:should_send_to_api?).and_return(true)
+    exception = mock('exception')
+    controller = mock('controller')
+    request = mock('request')
+    Sfalma::ControllerExceptionData.should_receive(:new).with(exception,controller,request).and_return(data = mock('exception_data'))
+    Sfalma::Remote.should_receive(:error).with(data)
+    Sfalma::Catcher.handle_with_controller(exception,controller,request)
+  end
+end