crashlog 0.0.1 → 0.0.2

data/lib/crash_log/configuration.bak.rb

@@ -0,0 +1,199 @@
+module CrashLog
+  class Configuration
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(CrashLog.configuration.project_root) &&
+          CrashLog.configuration.project_root.to_s != ''
+          line.sub(/#{CrashLog.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/crash_log} }
+    ].freeze
+
+    ENVIRONMENT_FILTERS = []
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+    # The default logging device
+    #
+    # This will be set to Rails.logger automatically if using Rails,
+    # otherwise it defaults to STDOUT.
+    attr_accessor :logger
+
+    # The API key to authenticate this project with CrashLog
+    #
+    # Get this from your projects configuration page within http://CrashLog.io
+    attr_accessor :api_key
+
+    # Stages (environments) which we consider to be in a production environment
+    # and thus you want to be sent notifications for.
+    attr_accessor :release_stages
+
+    # The name of the current stage
+    attr_reader :stage
+
+    # Project Root directory
+    attr_accessor :project_root
+    alias :root :project_root
+    alias :root= :project_root=
+
+    # If set, this will serialize the object returned by sending this key to
+    # the controller context. You can use this to send user data CrashLog to
+    # correlate errors with users to give you more advanced data about directly
+    # who was affected.
+    #
+    # All user data is stored encrypted for security and always remains your
+    # property.
+    attr_accessor :user_context_key
+
+    # Reporter configuration options
+    #
+    # Host to send exceptions to. Default: crashlog.io
+    attr_accessor :host
+
+    # Port to use for http connections. 80 or 443 by default.
+    attr_writer :port
+
+    def port
+      if @port
+        @port
+      else
+        secure? ? 443 : 80
+      end
+    end
+
+    # HTTP transfer scheme, default: https
+    attr_accessor :scheme
+
+    # API endpoint to context for notifications. Default /notify
+    attr_accessor :endpoint
+
+    # The faraday adapter to use to make the connection.
+    #
+    # Possible values are:
+    # - :test
+    # - :net_http
+    # - :net_http_persistent
+    # - :typhoeus
+    # - :patron
+    # - :em_synchrony
+    # - :em_http
+    # - :excon
+    # - :rack
+    # - :httpclient
+    #
+    # Possible performance gains can be made by using the em based adapters if
+    # your application supports this architecture.
+    #
+    # Default: net_http
+    attr_accessor :adapter
+
+    # Reader for Array of ignored error class names
+    attr_reader :ignore
+
+    attr_reader :announce_endpoint, :announce
+
+    # Send context lines for backtrace.
+    #
+    # Takes an integer of the number of lines, set to false or nil to disable.
+    attr_accessor :context_lines
+
+    # Environment variables to discard from ENV.
+    attr_accessor :environment_filters
+
+    # Framework name
+    attr_accessor :framework
+
+    attr_accessor :dry_run
+
+    attr_accessor :http_read_timeout, :http_open_timeout
+
+    def initialize
+      @dry_run                  = false
+      @secure                   = true
+      @use_system_ssl_cert_chain= false
+      @host                     = 'crashlog.io'
+      @http_open_timeout        = 5
+      @http_read_timeout        = 2
+      @adapter                  = :net_http
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @environment_filters      = ENVIRONMENT_FILTERS.dup
+      @ignore_by_filters        = []
+      @ignore                   = IGNORE_DEFAULT.dup
+      @release_stages           = %w(production staging)
+      @notifier_version         = CrashLog::VERSION
+      @notifier_url             = 'https://github.com/ivanvanderbyl/crashlog'
+      @framework                = 'Standalone'
+      @stage                    = 'development'
+      @host                     = 'stdin.crashlog.io'
+      @port                     = nil
+      @scheme                   = port.eql?(443) ? 'https' : 'http'
+      @endpoint                 = '/notify'
+      @announce                 = true
+      @announce_endpoint        = '/announce'
+      @context_lines            = 5
+      @framework                = 'Standalone'
+    end
+
+    def release_stage?
+      @release_stages.include?(stage)
+    end
+
+    def stage=(name)
+      @stage = name.downcase.strip
+    end
+
+    # Is this configuration valid for sending exceptions to CrashLog
+    #
+    # Returns true if all required keys are provided, otherwise false
+    def valid?
+      [:api_key, :host, :port].all? do |key|
+        !__send__(key).nil?
+      end
+    end
+
+    def ignored?(exception)
+      ignore.include?(error_class(exception))
+    end
+
+    def secure?
+      scheme == 'https'
+    end
+
+    # Hash like accessor
+    def [](key)
+      if self.respond_to?(key)
+        self.__send__(key)
+      end
+    end
+
+  private
+
+    def error_class(exception)
+      # The "Class" check is for some strange exceptions like Timeout::Error
+      # which throw the error class instead of an instance
+      (exception.is_a? Class) ? exception.name : exception.class.name
+    end
+
+  end
+end

data/lib/crash_log/configuration.rb

@@ -0,0 +1,188 @@
+require 'hashr'
+module CrashLog
+  class Configuration < Hashr
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(CrashLog.configuration.root) &&
+           CrashLog.configuration.root.to_s != ''
+          line.sub(/#{CrashLog.configuration.root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/crash_log} }
+    ].freeze
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+
+      # The logger to use for internal messages
+    define :logger => nil,
+
+      # The API key to authenticate this project with CrashLog
+      #
+      # Get this from your projects configuration page within http://CrashLog.io
+      :api_key => nil,
+      :project_id => nil,
+
+      # Stages (environments) which we consider to be in a production environment
+      # and thus you want to be sent notifications for.
+      :release_stages => ['staging', 'production'],
+
+      # The name of the current stage
+      :stage => 'development',
+
+      # Project Root directory
+      :project_root => nil,
+
+      # If set, this will serialize the object returned by sending this key to
+      # the controller context. You can use this to send user data CrashLog to
+      # correlate errors with users to give you more advanced data about directly
+      # who was affected.
+      #
+      # All user data is stored encrypted for security and always remains your
+      # property.
+      :user_context_key => nil,
+
+      # Reporter configuration options
+      #
+      # Host to send exceptions to. Default: crashlog.io
+      :host => 'stdin.crashlog.io',
+
+      # Port to use for http connections. 80 or 443 by default.
+      # :port => 443,
+
+      # HTTP transfer scheme, default: https
+      :scheme => 'https',
+
+      # API endpoint to context for notifications. Default /events
+      :endpoint => '/events',
+
+      # The faraday adapter to use to make the connection.
+      #
+      # Possible values are:
+      # - :test
+      # - :net_http
+      # - :net_http_persistent
+      # - :typhoeus
+      # - :patron
+      # - :em_synchrony
+      # - :em_http
+      # - :excon
+      # - :rack
+      # - :httpclient
+      #
+      # Possible performance gains can be made by using the em based adapters if
+      # your application supports this architecture.
+      #
+      # Default: net_http
+      :adapter => :net_http,
+
+      # Timeout for actually sending the exeption payload
+      :http_read_timeout => 2,
+
+      # Timeout for connecting to CrashLog collector interface
+      :http_open_timeout => 5,
+
+      # Ignored error class names
+      :ignore => IGNORE_DEFAULT.dup,
+
+      # Endpoint used for announcing application launch
+      :announce_endpoint => '/announce',
+      :announce => true,
+
+      # Send context lines for backtrace.
+      #
+      # Takes an integer of the number of lines, set to nil to disable.
+      :context_lines => 5,
+
+      # Environment variables to discard from ENV.
+      :environment_filters => [],
+
+      # Framework name
+      :framework => 'Standalone',
+
+      # Run in dry mode (Doesn't actually send exceptions, used for testing)
+      :dry_run => false,
+
+      :backtrace_filters => DEFAULT_BACKTRACE_FILTERS.dup,
+
+      :params_filters => DEFAULT_PARAMS_FILTERS.dup,
+
+      # Internal
+      # Do not change unless you know what this does.
+      :service_name => 'CrashLog'
+
+    def root
+      fetch(:project_root)
+    end
+
+    def root=(string)
+      self[:project_root] = string
+    end
+
+    def port
+      if secure?
+        443
+      else
+        fetch(:port, 80)
+      end
+    end
+
+    # Release stages are stages which send exceptions
+    def release_stage?
+      release_stages.include?(stage)
+    end
+
+    # Set the current stage
+    def stage=(name)
+      self[:stage] = name.downcase.strip
+    end
+
+    # Is this configuration valid for sending exceptions to CrashLog
+    #
+    # Returns true if all required keys are provided, otherwise false
+    def valid?
+      [:api_key, :project_id, :host, :port].all? do |key|
+        !__send__(key).nil?
+      end
+    end
+
+    def ignored?(exception)
+      ignore.include?(error_class(exception))
+    end
+
+    def secure?
+      fetch(:scheme, 'https') == 'https'
+    end
+
+    def notifier_version
+      CrashLog::VERSION
+    end
+
+  private
+
+    def error_class(exception)
+      # The "Class" check is for some strange exceptions like Timeout::Error
+      # which throw the error class instead of an instance
+      (exception.is_a? Class) ? exception.name : exception.class.name
+    end
+
+  end
+end

data/lib/crash_log/logging.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/aliasing'
+require 'logger'
+
+module CrashLog
+  module Logging
+    ANSI = {
+      :red    => 31,
+      :green  => 32,
+      :yellow => 33,
+      :cyan   => 36
+    }
+
+    def self.included(base)
+      base.__send__(:include, ClassMethods)
+    end
+
+    module ClassMethods
+      delegate :logger, :to => CrashLog
+
+      [:fatal, :error, :warn, :info, :debug].each do |level|
+        define_method(level) do |*args|
+          message, options = *args
+          message.chomp.split("\n").each do |line|
+            logger.send(level, prefix(line))
+          end
+        end
+      end
+
+      def prefix(string)
+        [CrashLog::LOG_PREFIX, string].join(' ')
+      end
+
+      def colorize(color, text)
+        "\e[#{ANSI[color]}m#{text}\e[0m"
+      end
+
+      def log_exception(exception)
+        logger.error("#{exception.class.name}: #{exception.message}")
+        exception.backtrace.each { |line| logger.error(line) } if exception.backtrace
+      rescue Exception => e
+        puts '--- FATAL ---'
+        puts 'an exception occured while logging an exception'
+        puts e.message, e.backtrace
+        puts exception.message, exception.backtrace
+      end
+
+    end
+
+  end
+end

data/lib/crash_log/payload.rb

@@ -0,0 +1,157 @@
+require 'rabl'
+
+module CrashLog
+  class Payload
+    include Logging
+
+    def self.build(exception, config, &block)
+      payload = new(exception, config)
+      yield(payload) if block_given?
+      payload
+    end
+
+    # Delivers this payload to CrashLog
+    #
+    # Captures any exceptions and logs them.
+    def deliver!
+      deliver
+    rescue Exception => e
+      error('Failed to deliver notification to CrashLog collector')
+      log_exception(e)
+    end
+
+    attr_reader :config, :backtrace_filters
+
+    def initialize(event_data, config)
+      @config = config || {}
+      @event_data = event_data
+      @context = {}
+      @environment = {}
+      @backtrace_filters = config[:backtrace_filters] || []
+
+      # Actually serialize the exception/event hash for transport
+      @event = serialize_event(event_data)
+
+      # add_environment_data(:system => SystemInformation.to_hash)
+    end
+
+    def deliver
+      Reporter.new(config).notify(self.body)
+    end
+
+    attr_reader :event, :backtrace, :exception_object, :environment, :context
+
+    def body
+      renderer.render
+    end
+
+    def add_context(data)
+      (@context ||= {}).merge!(data) if data.is_a?(Hash)
+    end
+
+    def add_user_data(data, value = nil)
+      if data.respond_to?(:keys)
+        @user_data.merge!(data)
+      elsif value && data.respond_to?(:to_sym)
+        @user_data[data.to_sym] = value
+      end
+    end
+
+    def add_session_data(data)
+      (@environment[:session] ||= {}).merge!(data) if data.is_a?(Hash)
+    end
+
+    def add_environment_data(data)
+      @environment.merge!(data) if data.respond_to?(:keys)
+    end
+
+    # The canonical time this exception occurred.
+    #
+    # Other notifiers leave this to the collector to set, we however take time
+    # more seriously and use this figure internally to detect processing time
+    # irregularities.
+    #
+    # Returns UNIX UTC timestamp integer.
+    def timestamp
+      Time.now.utc.to_i
+    end
+
+    # Various meta data about this notifier gem
+    def notifier
+      {
+        :name => "crashlog",
+        :version => CrashLog::VERSION
+      }
+    end
+
+    # Returns the hostname of this machine
+    def hostname
+      SystemInformation.hostname
+    end
+
+  private
+
+    def serialize_event(event_data)
+      if event_data.is_a?(Exception)
+        @backtrace = build_backtrace(event_data)
+        serialize_exception(event_data)
+
+      elsif event_data.is_a?(Hash)
+        event_data.merge(:timestamp => timestamp)
+
+      elsif event_data.respond_to?(:message) && event_data.respond_to?(:type)
+        ducktype_event(event_data)
+
+      end
+    end
+
+    def ducktype_event(event_data)
+      {}.tap do |response|
+        response[:timestamp] = timestamp
+        response[:type] = event_data.type
+        response[:message] = event_data.message
+      end
+    end
+
+    def serialize_exception(exception)
+      exception = unwrap_exception(exception)
+      # opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+      # opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+
+      {}.tap do |response|
+        response[:timestamp] = timestamp
+        response[:message] = exception.message
+        response[:type] = error_class(exception)
+      end
+    end
+
+    def build_backtrace(exception)
+      Backtrace.parse((exception.backtrace || caller),
+                      :filters => @backtrace_filters).to_a
+    end
+
+    def error_class(exception)
+      # The "Class" check is for some strange exceptions like Timeout::Error
+      # which throw the error class instead of an instance
+      (exception.is_a? Class) ? exception.name : exception.class.name
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
+    end
+
+    def renderer
+      Rabl::Renderer.new('payload', self, { :format => 'hash', :view_path => view_path })
+    end
+
+    def view_path
+      File.expand_path('../templates', __FILE__)
+    end
+  end
+end

data/lib/crash_log/rack.rb

@@ -0,0 +1,47 @@
+module CrashLog
+  # CrashLog Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to CrashLog and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'crashlog'
+  #
+  #   CrashLog.configure do |config|
+  #     config.api_key = 'project-api-key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     run lambda { |env| raise "Fully Racked" }
+  #   end
+  #
+  #   use CrashLog::Rack
+  #   run app
+  #
+  # Use a standard CrashLog.configure call to configure your api key.
+
+  class Rack
+    def initialize(app)
+      @app = app
+      CrashLog.configuration.logger ||= Logger.new($stdout)
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => exception
+        error_id = CrashLog.notify(exception, :rack_env => env)
+        env['crash_log.error_id'] = error_id
+        raise
+      end
+
+      if env['rack.exception']
+        error_id = CrashLog.notify(env['rack.exception'], :rack_env => env)
+        env['crash_log.error_id'] = error_id
+      end
+
+      response
+    end
+  end
+end
+

data/lib/crash_log/rails/action_controller_rescue.rb

@@ -0,0 +1,32 @@
+module CrashLog
+  module Rails
+
+    # CrashLog controller integration
+    # Aliases method chain for Rails internal rescue action
+    module ActionControllerRescue
+      def self.included(base)
+        base.send(:alias_method, :rescue_action_in_public_without_crash_log, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_crash_log)
+
+        base.send(:alias_method, :rescue_action_locally_without_crash_log, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_crash_log)
+      end
+
+    private
+
+      # crash_log_context is defined in controller_methods.rb
+      def rescue_action_in_public_with_crash_log(exception)
+        crash_log.auto_notify(exception, crash_log_context)
+        rescue_action_in_public_without_crash_log(exception)
+      end
+
+      # crash_log_context is defined in controller_methods.rb
+      def rescue_action_locally_with_crash_log(exception)
+        crash_log.auto_notify(exception, crash_log_context)
+        rescue_action_locally_without_crash_log(exception)
+      end
+    end
+  end
+
+end
+