crashlog 0.0.1 → 0.0.2

data/lib/crash_log/rails/controller_methods.rb

@@ -0,0 +1,45 @@
+module CrashLog
+  module Rails
+    module ControllerMethods
+
+      def crash_log_context
+        { :parameters       => crash_log_filter_if_filtering(params.to_hash),
+          :session_data     => crash_log_filter_if_filtering(crash_log_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => crash_log_request_url,
+          :cgi_data         => crash_log_filter_if_filtering(request.env)
+        }
+      end
+
+    private
+      def notify_crashlog(exception, custom_data = nil)
+        request_data = crash_log_context
+        #request_data[:meta_data][:custom] = custom_data if custom_data
+        CrashLog.notify(exception, request_data)
+      end
+
+      alias_method :notify_airbrake, :notify_crashlog
+
+      def crash_log_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def crash_log_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+
+    end
+  end
+end

data/lib/crash_log/rails/middleware/debug_exception_catcher.rb

@@ -0,0 +1,43 @@
+module CrashLog
+  module Rails
+    module Middleware
+      module DebugExceptionCatcher
+
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :crash_log)
+        end
+
+        # Hook into the rails error rendering page to send this exception to
+        # CrashLog before rails handlers take over.
+        def render_exception_with_crash_log(env, exception)
+          controller = env['action_controller.instance']
+
+          env['crash_log.error_id'] = CrashLog.notify(exception) #,
+                                                      # crash_log_context(controller, env))
+
+          if defined?(controller.rescue_action_in_public_without_crash_log)
+            controller.rescue_action_in_public_without_crash_log(exception)
+          end
+
+        rescue Exception => e
+          # If it breaks here there is possibly something wrong with us, so
+          # instead of crashing again, we'll just pass it on.
+        ensure
+          render_exception_without_crash_log(env, exception)
+        end
+
+      private
+
+        def crash_log_context(controller, env)
+          # TODO: Replace this with user context lookup
+          if controller.respond_to?(:crash_log_request_data)
+            controller.crash_log_request_data
+          else
+            {:rack_env => env}
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/crash_log/rails.rb

@@ -0,0 +1,32 @@
+require "crash_log"
+require "crash_log/rails/controller_methods"
+require "crash_log/rails/action_controller_rescue"
+
+# Rails 2.x support
+module CrashLog
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, CrashLog::Rails::ActionControllerRescue)
+        ActionController::Base.send(:include, CrashLog::Rails::ControllerMethods)
+      end
+
+      # Try to find where to log to
+      rails_logger = nil
+      if defined?(::Rails.logger)
+        rails_logger = ::Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        rails_logger = RAILS_DEFAULT_LOGGER
+      end
+
+      CrashLog.configure do |config|
+        config.logger = rails_logger
+        config.release_stage = RAILS_ENV  if defined?(RAILS_ENV)
+        config.project_root = RAILS_ROOT if defined?(RAILS_ROOT)
+        config.framework = "Rails: #{::Rails::VERSION::STRING}" if defined?(::Rails::VERSION)
+      end
+    end
+  end
+end
+
+CrashLog::Rails.initialize

data/lib/crash_log/railtie.rb

@@ -0,0 +1,41 @@
+require 'crash_log'
+require 'rails'
+
+# Rails 3.x support
+module CrashLog
+  class Railtie < ::Rails::Railtie
+
+    config.after_initialize do
+      CrashLog.configure do |config|
+        config.logger           ||= ::Rails.logger
+        config.stage            ||= ::Rails.env
+        config.project_root     ||= ::Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+
+      initializer "crash_log.use_rack_middleware" do |app|
+        app.config.middleware.insert 0, "CrashLog::Rack"
+      end
+
+      # Attach our Rails Controller methods
+      ActiveSupport.on_load(:action_controller) do
+        # Lazily load action_controller methods
+        require 'crash_log/rails/controller_methods'
+
+        include CrashLog::Rails::ControllerMethods
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
+        require 'crash_log/rails/middleware/debug_exception_catcher'
+        ::ActionDispatch::DebugExceptions.__send__(:include, CrashLog::Rails::Middleware::DebugExceptionCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+
+        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
+        # catch the exceptions in ShowExceptions.
+        require 'crash_log/rails/middleware/debug_exception_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include, CrashLog::Rails::Middleware::DebugExceptionCatcher)
+      end
+    end
+  end
+end

data/lib/crash_log/reporter.rb

@@ -0,0 +1,105 @@
+require 'faraday'
+require 'faraday/request/hmac_authentication'
+require 'uuid'
+require 'yajl'
+
+module CrashLog
+  class Reporter
+    include Logging
+
+    attr_reader :host, :port, :scheme, :endpoint, :announce_endpoint
+    attr_reader :result, :config, :response
+
+    def initialize(config)
+      @config     = config
+      @scheme     = config.scheme
+      @host       = config.host
+      @port       = config.port
+      @endpoint   = config.endpoint
+      @announce_endpoint = config.announce == true ?
+                           config.announce_endpoint : nil
+    end
+
+    def notify(payload)
+      #return if dry_run?
+      #MultiJson.use(:yajl)
+      response = post(endpoint, MultiJson.encode({:payload => payload}))
+      @response = response
+      report_result(response.body)
+      response.success?
+    rescue => e
+      log_exception e
+      error("Sending exception failed due to a connectivity issue")
+    end
+
+    def announce
+      return if dry_run?
+      return "Unknown application" unless announce_endpoint
+
+      response = post(config.announce_endpoint, JSON.dump(identification_hash))
+      if response.status == 201
+        JSON.load(response.body).symbolize_keys.fetch(:application, 'Default')
+      else
+        false
+      end
+    rescue => e
+      # We only want to log our mess when testing
+      log_exception(e) # if respond_to?(:should)
+      error("Failed to announce application launch")
+      nil
+    end
+
+    def report_result(body)
+      @result = JSON.load(body).symbolize_keys
+    end
+
+    def url
+      URI.parse("#{scheme}://#{host}:#{port}")
+    end
+
+    def identification_hash
+      {
+        :hostname => SystemInformation.hostname,
+        :timestamp => Time.now.utc.to_i
+      }
+    end
+
+    def print_result
+
+    end
+
+    def dry_run?
+      config.dry_run == true
+    end
+
+    def post(endpoint, body)
+      connection.post do |req|
+        req.url(endpoint)
+        # req.sign!(config.project_id, config.api_key)
+        req.headers['Content-Type'] = 'application/json'
+        req.body = body
+      end
+    end
+
+#  private
+
+    def connection
+      @connection ||= begin
+        Faraday.new(:url => url) do |faraday|
+          faraday.request :hmac_authentication, config.project_id, config.api_key, {:service_id => config.service_name}
+          faraday.adapter(adapter)
+          faraday.request :url_encoded
+          # faraday.request                 :token_auth, config.api_key
+          # faraday.response                :logger
+          # faraday.options[:timeout]       = config.http_read_timeout
+          # faraday.options[:open_timeout]  = config.http_open_timeout
+          # faraday.ssl[:verify]            = false
+        end
+      end
+    end
+
+    def adapter
+      config.adapter
+    end
+  end
+end

data/lib/crash_log/system_information.rb

@@ -0,0 +1,64 @@
+module CrashLog
+  class SystemInformation
+    class << self
+
+      def to_hash
+        {
+          :hostname => hostname,
+          :ruby_version => ruby_version,
+          :username => username,
+          :environment => environment,
+          :libraries_loaded => libraries_loaded,
+          :platform => platform,
+          :application_root => application_root,
+          :stage => stage
+        }
+      end
+
+      def hostname
+        require 'socket' unless defined?(Socket)
+        Socket.gethostname
+      rescue
+        'UNKNOWN'
+      end
+
+      def ruby_version
+        "#{RUBY_VERSION rescue '?.?.?'}-p#{RUBY_PATCHLEVEL rescue '???'} #{RUBY_RELEASE_DATE rescue '????-??-??'} #{RUBY_PLATFORM rescue '????'}"
+      end
+
+      def username
+        ENV['LOGNAME'] || ENV['USER'] || ENV['USERNAME'] || ENV['APACHE_RUN_USER'] || 'UNKNOWN'
+      end
+
+      def environment
+        if ENV.respond_to?(:to_hash)
+          ENV.to_hash.reject do |k, v|
+            (k =~ /^HTTP_/) || CrashLog.configuration.environment_filters.include?(k)
+          end
+        else
+          {}
+        end
+      end
+
+      def libraries_loaded
+        Hash[*Gem.loaded_specs.map {|name, gem_specification|
+          [name, gem_specification.version.to_s]
+        }.flatten]
+      rescue
+        {}
+      end
+
+      def platform
+        RUBY_PLATFORM rescue '????'
+      end
+
+      def application_root
+        CrashLog.configuration.root
+      end
+
+      def stage
+        CrashLog.configuration.stage
+      end
+    end
+  end
+end

data/lib/crash_log/templates/payload.rabl

@@ -0,0 +1,7 @@
+object @payload
+
+attribute :notifier
+attribute :event
+attribute :backtrace
+attribute :environment
+attribute :context

data/lib/crash_log/version.rb

@@ -1,3 +1,3 @@
 module CrashLog
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/crash_log.rb

@@ -1,5 +1,123 @@
+$: << File.expand_path('..', __FILE__)
+
 require 'crash_log/version'
+begin
+  require 'active_support'
+  require 'active_support/core_ext'
+rescue LoadError
+  require 'activesupport'
+  require 'activesupport/core_ext'
+end
+require 'faraday'
+require 'crash_log/railtie' if defined?(Rails::Railtie)
+
+require 'crash_log/logging'
 
 module CrashLog
+  extend Logging::ClassMethods
+
+  autoload :Backtrace,          'crash_log/backtrace'
+  autoload :Configuration,      'crash_log/configuration'
+  autoload :Payload,            'crash_log/payload'
+  autoload :Rack,               'crash_log/rack'
+  autoload :Reporter,           'crash_log/reporter'
+  autoload :SystemInformation,  'crash_log/system_information'
+
+  LOG_PREFIX = '** [CrashLog]'
+
+  class << self
+
+    # Sends a notification to CrashLog
+    #
+    # This is the main entry point into the exception sending stack.
+    #
+    # Examples:
+    #
+    #   def something_dangerous
+    #     raise RuntimeError, "This is too dangerous for you"
+    #   rescue => e
+    #     CrashLog.notify(e)
+    #   end
+    #
+    #   You can also include information about the current user and Crashlog
+    #   will allow you to correlate errors by affected users:
+    #
+    #   def something_dangerous
+    #     raise RuntimeError, "This is too dangerous for you"
+    #   rescue => e
+    #     CrashLog.notify(e, {current_user: current_user})
+    #   end
+    #
+    #   This will try to serialize the current user by calling `as_crashlog_context` or `as_json`
+    #   otherwise it will try `to_s`
+    #
+    # Returns true if successful, otherwise false
+    def notify(exception, context = {})
+      send_notification(exception, context)
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions.
+    def notify_or_ignore(exception, context = {})
+      send_notification(exception, context = {}) unless ignored?(exception)
+    end
+
+    # Print a message at the top of the applciation's logs to say we're ready.
+    def report_for_duty!
+      application = CrashLog::Reporter.new(configuration).announce
+
+      if application
+        info("Initialized and ready to handle exceptions for #{application}")
+      else
+        error("Failed to report for duty, your application failed to authenticate correctly with stdin.crashlog.io")
+      end
+    end
+
+    # Configure the gem to send notifications, at the very least an api_key is
+    # required.
+    def configure
+      yield(configuration) if block_given?
+      if configuration.valid?
+        report_for_duty!
+      else
+        error('Not configured correctly')
+      end
+    end
+
+    # The global configuration object.
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # The default logging device.
+    def logger
+      self.configuration.logger || Logger.new($stdout)
+    end
+
+    # Is the logger live
+    #
+    # Returns true if the current stage is included in the release
+    # stages config, false otherwise.
+    def live?
+      configuration.release_stage?
+    end
+
+    # Looks up ignored exceptions
+    #
+    # Returns true if this exception should be ignored, false otherwise.
+    def ignored?(exception)
+      configuration.ignored?(exception)
+    end
+
+  private
+
+    def send_notification(exception, context = {})
+      build_payload(exception, context).deliver! if live?
+    end
 
+    def build_payload(exception, context = {})
+      Payload.build(exception, configuration) do |payload|
+        payload.add_context(context)
+      end
+    end
+  end
 end

data/lib/faraday/request/hmac_authentication.rb

@@ -0,0 +1,73 @@
+module Faraday
+  class Request
+
+    require 'crash_log/auth_hmac'
+    require 'uri'
+
+    attr_reader :access_id, :secret
+
+    # # Sign the request with the specified `access_id` and `secret`.
+    # def sign!(access_id, secret)
+    #   @access_id, @secret = access_id, secret
+
+    #   #self.sign_with = access_id
+    #   #CrashLog::AuthHMAC.keys[access_id] = secret
+    # end
+
+    class HMACAuthentication < Faraday::Middleware
+      # Modified CanonicalString to know how to pull from the Faraday-specific
+      # env hash.
+      class CanonicalString < CrashLog::AuthHMAC::CanonicalString
+        def request_method(request)
+          request[:method].to_s.upcase
+        end
+
+        def request_body(request)
+          request[:body]
+        end
+
+        # def request_path(request)
+        #   URI.parse(request[:url]).path
+        # end
+
+        def request_path(request)
+          URI.parse(request[:url].to_s).path
+        end
+
+        def headers(request)
+          request[:request_headers]
+        end
+      end
+
+      KEY = "Authorization".freeze
+
+      attr_reader :auth, :token, :secret
+
+      def initialize(app, token, secret, options = {})
+        options.merge!(:signature => HMACAuthentication::CanonicalString)
+        keys = {token => secret}
+        @token, @secret = token, secret
+        @auth = CrashLog::AuthHMAC.new(keys, options)
+        super(app)
+      end
+
+      # Public
+      def call(env)
+        env[:request_headers][KEY] ||= hmac_auth_header(env).to_s #if sign_request?
+        puts env[:request_headers]
+        @app.call(env)
+      end
+
+      def hmac_auth_header(env)
+        auth.authorization(env, token, secret)
+      end
+
+      def sign_request?
+        !!@token && !!@secret
+      end
+    end
+  end
+
+  Faraday.register_middleware :request, :hmac_authentication => Faraday::Request::HMACAuthentication
+end
+

data/lib/rails/generators/crashlog/crashlog_generator.rb

@@ -0,0 +1,42 @@
+require 'rails/generators'
+
+class CrashlogGenerator < Rails::Generators::Base
+
+  class_option :api_key, :aliases => "-k", :type => :string, :desc => "Your CrashLog API key"
+
+  def self.source_root
+    @_crashlog_source_root ||= File.expand_path("../../../../../generators/crashlog/templates", __FILE__)
+  end
+
+  def install
+    ensure_api_key_was_configured
+    generate_initializer unless api_key_configured?
+    test_crashlog
+  end
+
+  private
+
+  def ensure_api_key_was_configured
+    if !options[:api_key] && !api_key_configured?
+      puts "Must pass --api-key or create config/initializers/crashlog.rb"
+      exit
+    end
+  end
+
+  def api_key_expression
+    "'#{options[:api_key]}'"
+  end
+
+  def generate_initializer
+    template 'initializer.rb', 'config/initializers/crashlog.rb'
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/crashlog.rb')
+  end
+
+  def test_crashlog
+    puts run("rake crashlog:test")
+  end
+end
+

data/rails/init.rb

@@ -0,0 +1 @@
+require "crash_log/rails"

data/spec/crash_log/backtrace_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe CrashLog::Backtrace do
+  let(:raised_error) do
+    begin
+      raise RuntimeError, "This broke"
+    rescue RuntimeError => e
+      e
+    end
+  end
+
+  describe '.parse' do
+    it 'accepts a standed caller array' do
+      CrashLog::Backtrace.parse(caller).to_a.size.should == caller.size
+    end
+
+    it 'accepts a ruby exception backtrace' do
+      CrashLog::Backtrace.parse(raised_error.backtrace).to_a.size.should ==
+          raised_error.backtrace.size
+    end
+  end
+
+  describe 'lines' do
+    it 'are converted into a parsed Line object' do
+      CrashLog::Backtrace.parse(raised_error.backtrace).lines.first.should be_a(CrashLog::Backtrace::Line)
+    end
+
+    it 'responds to to_hash' do
+      CrashLog::Backtrace.parse(raised_error.backtrace).lines.first.to_hash.should have_keys(:number, :method, :file)
+    end
+
+    it 'captures line context' do
+      line = CrashLog::Backtrace.parse(raised_error.backtrace).lines.first
+      line.context_line.should match /raise RuntimeError/
+    end
+
+    it 'captures pre_context' do
+      line = CrashLog::Backtrace.parse(raised_error.backtrace).lines.first
+      line.pre_context.should == [
+        "require \\'spec_helper\\'",
+        "",
+        "describe CrashLog::Backtrace do",
+        "  let(:raised_error) do",
+        "    begin"
+      ]
+    end
+
+    it 'captures pre_context' do
+      line = CrashLog::Backtrace.parse(raised_error.backtrace).lines.first
+      line.post_context.should == [
+        "    rescue RuntimeError => e",
+        "      e",
+        "    end",
+        "  end",
+        ""
+      ]
+    end
+  end
+
+  describe 'filters' do
+    it 'should replace project root with [PROJECT_ROOT]' do
+      CrashLog.configuration.project_root = File.expand_path('../../', __FILE__)
+      filters = CrashLog.configuration.backtrace_filters
+      backtrace = CrashLog::Backtrace.parse(raised_error.backtrace, :filters => filters)
+
+      backtrace.lines.first.file.should match /\[PROJECT_ROOT\]/
+      backtrace.lines.first.file.should == '[PROJECT_ROOT]/crash_log/backtrace_spec.rb'
+    end
+
+    it 'should not replace project root if it is not set' do
+      CrashLog.configuration.project_root = nil
+
+      filter = CrashLog::Configuration::DEFAULT_BACKTRACE_FILTERS
+      backtrace = CrashLog::Backtrace.parse(raised_error.backtrace, :filters => filter)
+
+      backtrace.lines.first.file.should_not match /\[PROJECT_ROOT\]/
+    end
+  end
+end