sfalma 0.7

data/bin/sfalma

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+case command
+  when 'help'
+    puts <<USAGE
+help               # Show this usage.
+test               # Send a test exception to Sfalma.
+alert <message>    # Send a message to Sfalma. Exits 0 for success, 1 for config error, and 2 for report failure
+install <api_key>  # Create config/sfalma.yml with your api_key. Overrites existing one.
+install <api_key> <environment> # Create config/sfalma.yml with your api_key and enabled for a specific environment. Overrites existing config file.
+install <api_key> <environment>,<environment> # Create config/sfalma.yml with your api_key enabled for multiple environments (comma seperated). Overrites existing config file.
+
+USAGE
+  when 'test'
+    if defined?(RAILS_ROOT)
+      puts "Loading Rails environment."
+      require(File.join('config', 'boot'))
+      require(File.join(RAILS_ROOT, 'config', 'environment')) if defined?(RAILS_ROOT)
+      require "sfalma/integration/tester"
+    else 
+      require 'json'
+      require 'sfalma'    
+      require "sfalma/integration/tester"      
+      Sfalma::Config.load('config/sfalma.yml')
+    end    
+    if Sfalma::Config.api_key
+      Sfalma::Integration.test
+    else
+      puts 'API key not configured'
+    end
+  when 'alert'
+    require "sfalma"
+    require "sfalma/alert_data"
+    require "sfalma/integration/alerter"
+    Sfalma::Config.load('config/sfalma.yml')
+    if Sfalma::Config.api_key
+      exit(Sfalma::Integration.alert(args[0]) ? 0 : 2)
+    else
+      puts 'API key not configured. Put sfalma.yml in current directory or /config'
+      exit(1)
+    end
+  when 'install'
+    api_key = args[0]
+    environments = args[1]
+    
+    if (api_key.nil?)
+      puts 'Missing required paramater <api-key>. Check your app configuration at http://sfalma.com.'
+    else
+      if (defined?(RAILS_ROOT) && !File.file?('config/environment.rb'))
+        puts "Run this command from the root of your rails application." and exit
+      else
+        Dir.mkdir('config') unless File.exists?('config')        
+      end
+    end        
+    config_file = File.open('config/sfalma.yml', 'w')
+    config_file.puts("api-key: #{api_key}\n")
+
+    unless(environments.nil?)
+      environments.split(',').each do |envo|
+        config_file.puts("#{envo}:\n")
+        config_file.puts("  enabled: true\n")
+      end
+    end
+    
+    config_file.close
+    puts "Config file written as config/sfalma.yml.";
+    puts "----------------------------------------------";
+    File.open('config/sfalma.yml').readlines.each do |line|
+      puts line
+    end
+    puts "----------------------------------------------";
+end

data/init.rb

@@ -0,0 +1,27 @@
+require 'sfalma'
+begin
+
+  if (Rails::VERSION::MAJOR < 3)    
+    Sfalma::Config.load(File.join(RAILS_ROOT, "/config/sfalma.yml"))
+    if Sfalma::Config.should_send_to_api?
+      Sfalma.logger.info("Loading Sfalma #{Sfalma::VERSION} for #{Rails::VERSION::STRING}")      
+      require File.join('sfalma', 'integration', 'rails')    
+      require File.join('sfalma', 'integration', 'dj') if defined?(Delayed::Job)
+    end
+  else
+    Sfalma::Config.load(File.join(Rails.root, "/config/sfalma.yml"))
+    
+    if Sfalma::Config.should_send_to_api?
+      Sfalma.logger.info("Loading Sfalma #{Sfalma::VERSION} for #{Rails::VERSION::STRING}")      
+      Rails.configuration.middleware.use "Rack::RailsSfalma"
+      require File.join('sfalma', 'integration', 'dj') if defined?(Delayed::Job)
+    end      
+  end
+
+  Sfalma::Startup.announce
+rescue => e
+  STDERR.puts "Problem starting Sfalma Plugin. Your app will run as normal. #{e.message}"
+  Sfalma.logger.error(e.message)
+  Sfalma.logger.error(e.backtrace)
+end
+

data/install.rb

@@ -0,0 +1,19 @@
+# This is the post install hook for when Sfalma is installed as a plugin.
+require 'fileutils'
+  
+# puts IO.read(File.join(File.dirname(__FILE__), 'README'))
+
+config_file = File.expand_path("#{File.dirname(__FILE__)}/../../../config/sfalma.yml")
+example_config_file = "#{File.dirname(__FILE__)}/sfalma.yml"
+
+if File::exists? config_file
+  puts "Sfalma config file already exists. Please ensure it is up-to-date with the current format."
+  puts "See #{example_config_file}"
+else  
+  puts "Installing default Sfalma config."
+  puts "  From #{example_config_file}"
+  puts "For sfalma to work you need to configure your API key."
+  puts "  See #{example_config_file}"
+  puts "If you don't have an API key, get one at http://www.sfalma.com/."
+  FileUtils.copy example_config_file, config_file
+end

data/lib/sfalma/alert_data.rb

@@ -0,0 +1,15 @@
+module Sfalma
+  class AlertData < ExceptionData
+    # Overwrite backtrace, since it is irrelevant
+    def extra_data
+      {
+        'exception' => {
+          'exception_class' => @exception.class.to_s,
+          'message' => @exception.message,
+          'backtrace' => "",
+          'occurred_at' => Time.now
+        }
+      }
+    end
+  end
+end

data/lib/sfalma/application_environment.rb

@@ -0,0 +1,79 @@
+require 'digest/md5'
+
+module Sfalma
+  class ApplicationEnvironment
+    def self.to_hash(framework)
+      env = extract_environment(ENV)
+      {
+        'client' => {
+          'name' => Sfalma::CLIENT_NAME,
+          'version' => Sfalma::VERSION,
+          'protocol_version' => Sfalma::PROTOCOL_VERSION
+        },
+        'application_environment' => {
+          'environment' => environment,
+          'host' => get_hostname,
+          'run_as_user' => get_username,
+          'app_home' => (application_root.to_s.respond_to?(:force_encoding) ? application_root.to_s.force_encoding("UTF-8") : application_root),
+          'gem_home' => env.fetch('GEM_HOME',''),
+          'language' => 'ruby',
+          'language_version' => language_version_string,
+          'framework' => framework,
+          'libraries_loaded' => libraries_loaded
+        }
+      }
+    end
+    
+    def self.to_hash_basic(framework)
+      {
+        'client' => {
+          'name' => Sfalma::CLIENT_NAME,
+          'version' => Sfalma::VERSION,
+          'protocol_version' => Sfalma::PROTOCOL_VERSION
+        },
+	      'application_environment' => {
+	        'environment' => environment,
+          'app_home' => (application_root.to_s.respond_to?(:force_encoding) ? application_root.to_s.force_encoding("UTF-8") : application_root),
+          'gem_home' => extract_environment(ENV).fetch('GEM_HOME','')
+	      }
+      }
+    end
+
+    def self.environment
+      Config.application_environment
+    end
+
+    def self.application_root
+      Config.application_root
+    end
+
+    def self.extract_environment(env)
+      env.reject do |k, v|
+        (k =~ /^HTTP_/) || Sfalma::ENVIRONMENT_FILTER.include?(k)
+      end
+    end
+
+    def self.get_hostname
+      require 'socket' unless defined?(Socket)
+      Socket.gethostname
+    rescue
+      'UNKNOWN'
+    end
+
+    def self.language_version_string
+      "#{RUBY_VERSION rescue '?.?.?'} p#{RUBY_PATCHLEVEL rescue '???'} #{RUBY_RELEASE_DATE rescue '????-??-??'} #{RUBY_PLATFORM rescue '????'}"
+    end
+
+    def self.get_username
+      ENV['LOGNAME'] || ENV['USER'] || ENV['USERNAME'] || ENV['APACHE_RUN_USER'] || 'UNKNOWN'
+    end
+
+    def self.libraries_loaded
+      begin
+        return Hash[*Gem.loaded_specs.map{|name, gem_specification| [name, gem_specification.version.to_s]}.flatten]
+      rescue
+      end
+      {}
+    end
+  end
+end

data/lib/sfalma/catcher.rb

@@ -0,0 +1,26 @@
+module Sfalma
+  class Catcher
+    class << self
+      def handle_with_controller(exception, controller=nil, request=nil)
+        if Config.should_send_to_api?
+          data = ControllerExceptionData.new(exception, controller, request)
+          Remote.error(data)
+        end
+      end
+      
+      def handle_with_rack(exception, environment, request) 
+        if Config.should_send_to_api?
+          data = RackExceptionData.new(exception, environment, request)
+          Remote.error(data)
+        end
+      end
+
+      def handle(exception, name=nil)
+        if Config.should_send_to_api?
+          data = ExceptionData.new(exception, name)
+          Remote.error(data)
+        end
+      end
+    end
+  end
+end

data/lib/sfalma/config.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+
+module Sfalma
+  class Config
+    class ConfigurationException < StandardError; end
+
+    class << self
+      DEFAULTS = {
+        :ssl => false,
+        :remote_host_http => 'http://www.sfalma.com',
+        :http_open_timeout => 2,
+        :http_read_timeout => 4,
+        :disabled_by_default => %w(development test)
+      }
+
+      attr_accessor :api_key, :enabled
+      attr_accessor :http_proxy_host, :http_proxy_port, :http_proxy_username, :http_proxy_password
+      attr_writer :ssl
+
+      def load(config_file=nil)
+        if (config_file && File.file?(config_file))
+          begin
+            config = YAML::load_file(config_file)
+            env_config = config[application_environment] || {}
+            @api_key = config['api-key'] || env_config['api-key']
+
+            @http_proxy_host = config['http-proxy-host']
+            @http_proxy_port = config['http-proxy-port']
+            @http_proxy_username = config['http-proxy-username']
+            @http_proxy_password = config['http-proxy-password']
+            @http_open_timeout = config['http-open-timeout']
+            @http_read_timeout = config['http-read-timeout'] 
+
+            @ssl = config['ssl'] || env_config['ssl']
+            @enabled = env_config['enabled']
+            @remote_port = config['remote-port'].to_i unless config['remote-port'].nil?
+            @remote_host = config['remote-host'] unless config['remote-host'].nil?
+            # VCS
+            @vcs = config['vcs'] unless config['vcs'].nil?
+          rescue Exception => e
+            raise ConfigurationException.new("Unable to load configuration #{config_file} for environment #{application_environment} : #{e.message}")
+          end
+        end
+      end
+      
+      def vcs
+        @vcs ||= nil
+      end
+      
+      def api_key
+        return @api_key unless @api_key.nil?
+        @api_key ||= ENV['EXCEPTIONAL_API_KEY'] unless ENV['EXCEPTIONAL_API_KEY'].nil?
+      end
+
+      def application_environment
+        ENV['RACK_ENV'] || ENV['RAILS_ENV']|| 'development'
+      end
+
+      def should_send_to_api?
+        return @enabled unless @enabled.nil?
+        @enabled = true#!(DEFAULTS[:disabled_by_default].include?(application_environment))
+      end
+
+      def application_root
+        (defined?(Rails) && Rails.respond_to?(:root)) ? Rails.root : Dir.pwd
+      end
+
+      def ssl?
+        @ssl ||= DEFAULTS[:ssl]
+      end
+
+      def remote_host
+        @remote_host ||= DEFAULTS[:remote_host_http]
+      end
+
+      def remote_port
+        @remote_port =80 #||= ssl? ? 443 : 80, we wait for naked domain SSL on GAE
+      end
+
+      def reset
+        @enabled = @ssl = @remote_host = @remote_port = @api_key = nil
+      end
+
+      def http_open_timeout
+        @http_open_timeout ||= DEFAULTS[:http_open_timeout]
+      end
+
+      def http_read_timeout
+        @http_read_timeout ||= DEFAULTS[:http_read_timeout]
+      end
+    end
+  end
+end

data/lib/sfalma/controller_exception_data.rb

@@ -0,0 +1,69 @@
+require 'digest/md5'
+
+module Sfalma
+  class ControllerExceptionData < ExceptionData
+    def initialize(exception, controller=nil, request=nil)
+      super(exception)
+      @request = request
+      @controller = controller
+    end
+
+    def framework
+      "rails"
+    end
+
+    def extra_stuff                                                                                               
+      return {} if @request.nil?
+
+      {
+        'request' => {
+          'url' => (@request.respond_to?(:url) ? @request.url : "#{@request.protocol}#{@request.host}#{@request.request_uri}"),
+          'controller' => @controller.class.to_s,
+          'action' => action_name,
+          'parameters' => filter_paramaters(@request.respond_to?(:parameters) ? @request.parameters : @request.params),
+          'request_method' => @request.request_method.to_s,
+          'remote_ip' => (@request.respond_to?(:remote_ip) ? @request.remote_ip : @request.ip),
+          'headers' => extract_http_headers(@request.env),
+          'session' => self.class.sanitize_session(@request)
+        }
+      }
+    end
+    
+    def action_name
+      action_name = ''
+      if @controller.respond_to?(:action_name) 
+        action_name = @controller.action_name.to_s
+      else
+        action_name = (@request.respond_to?(:parameters) ? @request.parameters['action'] : @request.params['action'])
+      end
+      action_name
+    end
+
+    def filter_hash(keys_to_filter, hash)
+      if keys_to_filter.is_a?(Array) && !keys_to_filter.empty?
+        hash.each do |key, value|
+          if value.respond_to?(:to_hash)
+            filter_hash(keys_to_filter, hash[key])
+          elsif key_match?(key, keys_to_filter)
+            hash[key] = "[FILTERED]"
+          end
+        end
+      end
+      hash
+    end
+
+    def key_match?(key, keys_to_filter)
+      keys_to_filter.map {|k| k.to_s}.include?(key.to_s)
+    end
+
+    def filter_paramaters(hash)                                                                                       
+      if @request.respond_to?(:env) && @request.env["action_dispatch.parameter_filter"]
+        filter_hash(@request.env["action_dispatch.parameter_filter"], hash)
+      elsif @controller.respond_to?(:filter_parameters)
+        @controller.send(:filter_parameters, hash)
+      else
+        hash
+      end
+    end
+  end
+end

data/lib/sfalma/exception_data.rb

@@ -0,0 +1,146 @@
+require 'digest/md5'
+require 'time'
+
+module Sfalma
+  class ExceptionData 
+    
+    def initialize(exception, name=nil)
+      @exception = exception
+      @name = name
+    end
+
+    def to_hash
+      # Do not send the environment for every exception
+      hash = ::Sfalma::ApplicationEnvironment.to_hash_basic(framework)
+      app_home = hash['application_environment']['app_home']
+      gem_home = hash['application_environment']['gem_home']
+      line_and_number = where(@exception.backtrace, app_home, gem_home)
+      
+      hash.merge!({
+        'exception' => {
+          'klass' => @exception.class.to_s,
+          'message' => @exception.message,
+          'backtrace' => normalize(@exception.backtrace, app_home, gem_home),
+          'occurred_at' => Time.now.utc.iso8601,
+          'where' => line_and_number
+        }
+      })
+      hash.merge!(extra_stuff)
+      hash.merge!(context_stuff)
+      #hash.merge!(::Sfalma::VCS(line_and_number, app_home).to_hash)
+      self.class.sanitize_hash(hash)
+    end
+    
+    def normalize(trace, app_home, gem_home)
+      trace.map do |line|
+        if !line.index(app_home).nil?
+          line.gsub!(app_home,'[APP_HOME]')
+        elsif !line.index(gem_home).nil?
+          line.gsub!(gem_home, '[GEM_HOME]')
+        end
+        line
+      end
+    end
+    
+    def where(trace, app_path, gem_path)
+      line_and_number = ''
+      trace.each do |line|
+        if !line.index(app_path).nil?
+          line_and_number = line[0,line.rindex(':')]
+          puts line
+          break
+        end
+      end
+      if line_and_number == ''
+        line_and_number = trace[0][0,trace[0].rindex(':')]
+      end
+      line_and_number.gsub!(app_path,'').gsub!(gem_path,'') rescue line_and_number
+      line_and_number
+    end
+
+    def extra_stuff
+      { 'rescue_block' => { 'name' => @name} }
+    end
+
+    def context_stuff
+      context = Thread.current[:exceptional_context]
+      (context.nil? || context.empty?) ? {} : {'context' => context}
+    end
+
+    def to_json
+      begin
+        to_hash.to_json
+      rescue NoMethodError
+        begin
+          require 'json'
+          return to_hash.to_json
+        rescue StandardError => e                   
+          Sfalma.logger.error(e.message)
+          Sfalma.logger.error(e.backtrace)                    
+          raise StandardError.new("You need a json gem/library installed to send errors to Sfalma (Object.to_json not defined). \nInstall json_pure, yajl-ruby, json-jruby, or the c-based json gem")
+        end
+      end
+    end
+    
+    def framework
+      nil
+    end    
+
+    def uniqueness_hash
+      return nil if (@exception.backtrace.nil? || @exception.backtrace.empty?)
+      # in case we have the same exception class at the same line but caused by different method
+      @exception.backtrace.push(@exception.message)
+      traces = @exception.backtrace.collect{ |line| 
+        line if line.scan(/_run__\d+__process_action__\d+__callbacks/).size<1 
+      }.compact
+      Digest::MD5.hexdigest(traces.join)
+    end
+
+    def self.sanitize_hash(hash)
+      case hash
+        when Hash
+          hash.inject({}) do |result, (key, value)|            
+            result.update(key => sanitize_hash(value))
+          end
+        when Array
+          hash.collect{|value| sanitize_hash(value)}
+        when Fixnum, String, Bignum
+          hash
+        else
+          hash.to_s
+      end
+    rescue Exception => e
+      Sfalma.logger.error(hash)
+      Sfalma.logger.error(e.message)
+      Sfalma.logger.error(e.backtrace)      
+      {}
+    end
+
+    def extract_http_headers(env)
+      headers = {}
+      env.select{|k, v| k =~ /^HTTP_/}.each do |name, value|
+        proper_name = name.sub(/^HTTP_/, '').split('_').map{|upper_case| upper_case.capitalize}.join('-')
+        headers[proper_name] = value
+      end
+      unless headers['Cookie'].nil?
+        headers['Cookie'] = headers['Cookie'].sub(/_session=\S+/, '_session=[FILTERED]')
+      end
+      headers
+    end  
+  
+    def self.sanitize_session(request)
+      session_hash = {'session_id' => "", 'data' => {}}
+
+      if request.respond_to?(:session)      
+        session = request.session
+        session_hash['session_id'] = request.session_options ? request.session_options[:id] : nil
+        session_hash['session_id'] ||= session.respond_to?(:session_id) ? session.session_id : session.instance_variable_get("@session_id")
+        session_hash['data'] = session.respond_to?(:to_hash) ? session.to_hash : session.instance_variable_get("@data") || {}
+        session_hash['session_id'] ||= session_hash['data'][:session_id]
+        session_hash['data'].delete(:session_id)
+      end
+
+      self.sanitize_hash(session_hash)
+    end  
+  end
+end

data/lib/sfalma/integration/alerter.rb

@@ -0,0 +1,11 @@
+module Sfalma
+  class Alert <StandardError;
+  end
+
+  module Integration
+    def self.alert(msg, env={})
+      return Sfalma::Remote.error(Sfalma::AlertData.new(Alert.new(msg), "Alert"))
+    end
+  end
+end
+

data/lib/sfalma/integration/dj.rb

@@ -0,0 +1,12 @@
+begin
+  class Delayed::Job
+    def log_exception_with_sfalma(e)
+      Sfalma.handle(e, "Delayed::Job #{self.name}")
+      log_exception_without_sfalma(e)
+      Sfalma.context.clear!
+    end
+    alias_method_chain :log_exception, :sfalma
+    Sfalma.logger.info "DJ integration enabled"
+  end
+rescue
+end

data/lib/sfalma/integration/rack.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rack'
+
+module Rack  
+  class Sfalma    
+
+    def initialize(app, api_key = nil)
+      @app = app
+      if api_key.nil?
+        sfalma_config = "config/sfalma.yml"
+        ::Sfalma::Config.load(sfalma_config)
+      else
+        ::Sfalma.configure(api_key)
+        ::Sfalma::Config.enabled = true
+        ::Sfalma.logger.info "Enabling Sfalma for Rack"
+      end
+    end    
+    
+    def call(env)
+      begin
+        status, headers, body =  @app.call(env)
+      rescue Exception => e
+        ::Sfalma::Catcher.handle_with_rack(e,env, Rack::Request.new(env))
+        raise(e)
+      end
+    end
+  end
+end

data/lib/sfalma/integration/rack_rails.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rack'
+
+module Rack  
+  class RailsSfalma    
+
+    def initialize(app)
+      @app = app
+    end    
+    
+    def call(env)
+      begin
+        body = @app.call(env)
+      rescue Exception => e
+        ::Sfalma::Catcher.handle_with_controller(e,env['action_controller.instance'], Rack::Request.new(env))
+        raise
+      end
+
+      if env['rack.exception']
+        ::Sfalma::Catcher.handle_with_controller(env['rack.exception'],env['action_controller.instance'], Rack::Request.new(env))
+      end
+
+      body
+    end      
+  end
+end

data/lib/sfalma/integration/rails.rb

@@ -0,0 +1,27 @@
+# force Rails < 2.0 to use quote keys as per the JSON standard...
+if defined?(ActiveSupport) && defined?(ActiveSupport::JSON) && ActiveSupport::JSON.respond_to?(:unquote_hash_key_identifiers)
+  ActiveSupport::JSON.unquote_hash_key_identifiers = false
+end
+
+if defined? ActionController
+  module ActionController
+    class Base
+      def rescue_action_with_exceptional(exception)
+        unless exception_handled_by_rescue_from?(exception)
+          Sfalma::Catcher.handle_with_controller(exception, self, request)
+          Sfalma.context.clear!
+        end
+        rescue_action_without_exceptional exception
+      end
+
+      alias_method :rescue_action_without_exceptional, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_exceptional
+      protected :rescue_action
+
+      private
+      def exception_handled_by_rescue_from?(exception)
+        respond_to?(:handler_for_rescue) && handler_for_rescue(exception)
+      end
+    end
+  end
+end

data/lib/sfalma/integration/sinatra.rb

@@ -0,0 +1,6 @@
+if defined? Sinatra::Request
+  error do
+    Sfalma::Catcher.handle_with_rack(request.env['sinatra.error'], request.env, request)
+    raise request.env['sinatra.error']
+  end
+end