sentry-raven 0.3.1 → 0.4.0

data/README.md

@@ -79,14 +79,58 @@ Raven.configure do |config|
   # manually configure environment if ENV['RACK_ENV'] is not defined
   config.current_environment = 'production'
 end
+```
+
+## Capturing Events
+
+Many implementations will automatically capture uncaught exceptions (such as Rails, Sidekiq or by using
+the Rack middleware). Sometimes you may want to catch those exceptions, but still report on them.
+
+Several helps are available to assist with this.
 
-Raven.capture # Global style
+### Capture Exceptions in a Block
 
-Raven.capture do # Block style
+```ruby
+Raven.capture do
+  # capture any exceptions which happen during execution of this block
   1 / 0
 end
 ```
 
+### Capture an Exception by Value
+
+```ruby
+begin
+  1 / 0
+rescue ZeroDivisionError => exception
+  Raven.capture_exception(exception)
+end
+```
+
+### Additional Context
+
+Additional context can be passed to the capture methods.
+
+```ruby
+Raven.capture_message("My event", {
+  :logger => 'logger',
+  :extra => {
+    'my_custom_variable' => 'value'
+  },
+  :tags => {
+    'environment' => 'production',
+  }
+})
+```
+
+The following attributes are available:
+
+* `logger`: the logger name to record this event under
+* `level`: a string representing the level of this event (fatal, error, warning, info, debug)
+* `server_name`: the hostname of the server
+* `tags`: a mapping of tags describing this event
+* `extra`: a mapping of arbitrary context
+
 ## Testing
 
 ```bash
@@ -127,7 +171,7 @@ end
 ## Sanitizing Data (Processors)
 
 If you need to sanitize or pre-process (before its sent to the server) data, you can do so using the Processors
-implementation. By default, a single processor is installed (Raven::Processors::SanitizeData), which will attempt to
+implementation. By default, a single processor is installed (Raven::Processor::SanitizeData), which will attempt to
 sanitize keys that match various patterns (e.g. password) and values that resemble credit card numbers.
 
 To specify your own (or to remove the defaults), simply pass them with your configuration:
@@ -137,14 +181,22 @@ require 'raven'
 
 Raven.configure do |config|
   config.dsn = 'http://public:secret@example.com/project-id'
-  config.processors = [Raven::Processors::SanitizeData]
+  config.processors = [Raven::Processor::SanitizeData]
 end
+```
+
+## Command Line Interface
+
+Raven includes a basic CLI for testing your DSN:
+
+```ruby
+ruby -Ilib ./bin/raven test <DSN>
+```
 
 Resources
 ---------
 
-* `Bug Tracker <http://github.com/getsentry/raven-ruby/issues>`_
-* `Code <http://github.com/getsentry/raven-ruby>`_
-* `Mailing List <https://groups.google.com/group/getsentry>`_
-* `IRC <irc://irc.freenode.net/sentry>`_  (irc.freenode.net, #sentry)
-
+* [Bug Tracker](http://github.com/getsentry/raven-ruby/issues>)
+* [Code](http://github.com/getsentry/raven-ruby>)
+* [Mailing List](https://groups.google.com/group/getsentry>)
+* [IRC](irc://irc.freenode.net/sentry>)  (irc.freenode.net, #sentry)

data/bin/raven

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "raven"
+require "optparse"
+
+options = {}
+
+parser = OptionParser.new do |opt|
+  opt.banner = "Usage: raven COMMAND [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     test: send a test event"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  # opt.on("-e","--environment ENVIRONMENT","which environment you want server run") do |environment|
+  #   options[:environment] = environment
+  # end
+
+  # opt.on("-d","--daemon","runing on daemon mode?") do
+  #   options[:daemon] = true
+  # end
+
+  opt.on("-h","--help","help") do
+    puts parser
+  end
+end
+
+parser.parse!
+
+case ARGV[0]
+  when "test"
+    dsn = ARGV[1] if ARGV.length > 1
+    if !dsn
+      puts "Usage: raven test <dsn>"
+    else
+      Raven.configure do |config|
+        config.dsn = dsn
+        config.current_environment = 'production'
+      end
+
+      puts "Sending test event"
+
+      begin
+        1 / 0
+      rescue ZeroDivisionError => exception
+        Raven.capture_exception(exception)
+      end
+
+      puts "Done!"
+
+    end
+  else
+    puts parser
+end

data/lib/raven.rb

@@ -1,4 +1,5 @@
 require 'raven/version'
+require 'raven/backtrace'
 require 'raven/configuration'
 require 'raven/logger'
 require 'raven/client'
@@ -11,6 +12,8 @@ require 'raven/interfaces/http'
 require 'raven/processors/sanitizedata'
 
 require 'raven/railtie' if defined?(Rails::Railtie)
+require 'raven/sidekiq' if defined?(Sidekiq)
+
 
 module Raven
   class << self
@@ -66,14 +69,14 @@ module Raven
     #   Raven.capture do
     #     MyApp.run
     #   end
-    def capture(&block)
+    def capture(options={}, &block)
       if block
         begin
           block.call
         rescue Error => e
           raise # Don't capture Raven errors
         rescue Exception => e
-          self.captureException(e)
+          capture_exception(e, options)
           raise
         end
       else
@@ -81,21 +84,24 @@ module Raven
         at_exit do
           if $!
             logger.debug "Caught a post-mortem exception: #{$!.inspect}"
-            self.captureException($!)
+            capture_exception($!, options)
           end
         end
       end
     end
 
-    def captureException(exception)
-      evt = Event.capture_exception(exception)
+    def capture_exception(exception, options={})
+      evt = Event.capture_exception(exception, options)
       send(evt) if evt
     end
 
-    def captureMessage(message)
-      evt = Event.capture_message(message)
+    def capture_message(message, options={})
+      evt = Event.capture_message(message, options)
       send(evt) if evt
     end
 
+    # For cross-language compat
+    alias :captureException :capture_exception
+    alias :captureMessage :capture_message
   end
 end

data/lib/raven/backtrace.rb

@@ -0,0 +1,121 @@
+## Inspired by Rails' and Airbrake's backtrace parsers.
+
+module Raven
+
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Handles backtrace parsing line by line
+    class Line
+
+      # regexp (optionnally allowing leading X: for windows support)
+      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      APP_DIRS_PATTERN = /^\/?(bin|app|config|lib|test)/
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line)
+        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+        new(file, number, method)
+      end
+
+      def initialize(file, number, method)
+        self.file = file
+        self.number = number.to_i
+        self.method = method
+      end
+
+      def in_app
+        if self.file =~ APP_DIRS_PATTERN
+          true
+        else
+          false
+        end
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      private
+
+      attr_writer :file, :number, :method
+    end
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end.compact
+
+      lines = filtered_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end

data/lib/raven/client.rb

@@ -29,9 +29,14 @@ module Raven
 
       Raven.logger.debug "Raven client connecting to #{self.configuration[:server]}"
 
-      @conn ||=  Faraday.new(:url => self.configuration[:server]) do |builder|
-        builder.adapter  Faraday.default_adapter
-      end
+      @conn ||=  Faraday.new(
+          :url => self.configuration[:server],
+          :ssl => {:verify => self.configuration.ssl_verification}
+        ) do |builder|
+          builder.adapter  Faraday.default_adapter
+          builder.options[:timeout] = self.configuration.timeout if self.configuration.timeout
+          builder.options[:open_timeout] = self.configuration.open_timeout if self.configuration.open_timeout
+        end
     end
 
 

data/lib/raven/configuration.rb

@@ -31,16 +31,34 @@ module Raven
     # Processors to run on data before sending upstream
     attr_accessor :processors
 
+    # Timeout when waiting for the server to return data in seconds
+    attr_accessor :timeout
+
+    # Timeout waiting for the connection to open in seconds
+    attr_accessor :open_timeout
+
+    # Should the SSL certificate of the server be verified?
+    attr_accessor :ssl_verification
+
     attr_reader :current_environment
 
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
     def initialize
       self.server = ENV['SENTRY_DSN'] if ENV['SENTRY_DSN']
       @context_lines = 3
       self.environments = %w[ production ]
       self.current_environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
       self.send_modules = true
-      self.excluded_exceptions = []
+      self.excluded_exceptions = IGNORE_DEFAULT
       self.processors = [Raven::Processor::SanitizeData]
+      self.ssl_verification = true
     end
 
     def server=(value)

data/lib/raven/event.rb

@@ -15,16 +15,17 @@ module Raven
       "warn" => 30,
       "warning" => 30,
       "error" => 40,
+      "fatal" => 50,
     }
 
     BACKTRACE_RE = /^(.+?):(\d+)(?::in `(.+?)')?$/
 
     attr_reader :id
     attr_accessor :project, :message, :timestamp, :level
-    attr_accessor :logger, :culprit, :server_name, :modules, :extra
+    attr_accessor :logger, :culprit, :server_name, :modules, :extra, :tags
 
-    def initialize(options={}, configuration=nil, &block)
-      @configuration = configuration || Raven.configuration
+    def initialize(options={}, &block)
+      @configuration = options[:configuration] || Raven.configuration
       @interfaces = {}
 
       @id = options[:id] || UUIDTools::UUID.random_create.hexdigest
@@ -34,6 +35,7 @@ module Raven
       @logger = options[:logger] || 'root'
       @culprit = options[:culprit]
       @extra = options[:extra]
+      @tags = options[:tags]
 
       # Try to resolve the hostname to an FQDN, but fall back to whatever the load name is
       hostname = Socket.gethostname
@@ -85,31 +87,45 @@ module Raven
       data['server_name'] = self.server_name if self.server_name
       data['modules'] = self.modules if self.modules
       data['extra'] = self.extra if self.extra
+      data['tags'] = self.tags if self.tags
       @interfaces.each_pair do |name, int_data|
         data[name] = int_data.to_hash
       end
       data
     end
 
-    def self.capture_exception(exc, configuration=nil, &block)
-      configuration ||= Raven.configuration
+    def self.capture_exception(exc, options={}, &block)
+      configuration = options[:configuration] || Raven.configuration
       if exc.is_a?(Raven::Error)
         # Try to prevent error reporting loops
         Raven.logger.info "Refusing to capture Raven error: #{exc.inspect}"
         return nil
       end
-      if configuration[:excluded_exceptions].include? exc.class.name
+      if configuration[:excluded_exceptions].any? { |x| x === exc || x == exc.class.name }
         Raven.logger.info "User excluded error: #{exc.inspect}"
         return nil
       end
-      self.new({}, configuration) do |evt|
+
+      context_lines = configuration[:context_lines]
+
+      new(options) do |evt|
         evt.message = "#{exc.class.to_s}: #{exc.message}"
-        evt.level = :error
+        evt.level = options[:level] || :error
         evt.parse_exception(exc)
         if (exc.backtrace)
           evt.interface :stack_trace do |int|
-            int.frames = exc.backtrace.reverse.map do |trace_line|
-              int.frame {|frame| evt.parse_backtrace_line(trace_line, frame) }
+            backtrace = Backtrace.parse(exc.backtrace)
+            int.frames = backtrace.lines.reverse.map do |line|
+              int.frame do |frame|
+                frame.abs_path = line.file
+                frame.function = line.method
+                frame.lineno = line.number
+                frame.in_app = line.in_app
+                if context_lines
+                  frame.pre_context, frame.context_line, frame.post_context = \
+                    evt.get_context(frame.abs_path, frame.lineno, context_lines)
+                end
+              end
             end
             evt.culprit = evt.get_culprit(int.frames)
           end
@@ -118,9 +134,8 @@ module Raven
       end
     end
 
-    def self.capture_rack_exception(exc, rack_env, configuration=nil, &block)
-      configuration ||= Raven.configuration
-      capture_exception(exc, configuration) do |evt|
+    def self.capture_rack_exception(exc, rack_env, options={}, &block)
+      capture_exception(exc, options) do |evt|
         evt.interface :http do |int|
           int.from_rack(rack_env)
         end
@@ -128,20 +143,30 @@ module Raven
       end
     end
 
-    def self.capture_message(message, configuration=nil)
-      configuration ||= Raven.configuration
-      self.new({}, configuration) do |evt|
+    def self.capture_message(message, options={})
+      new(options) do |evt|
         evt.message = message
-        evt.level = :error
+        evt.level = options[:level] || :error
         evt.interface :message do |int|
           int.message = message
         end
       end
     end
 
+    # Because linecache can go to hell
+    def self._source_lines(path, from, to)
+    end
+
+    def get_context(filename, lineno, context)
+      lines = (2 * context + 1).times.map do |i|
+        Raven::LineCache::getline(filename, lineno - context + i)
+      end
+      [lines[0..(context-1)], lines[context], lines[(context+1)..-1]]
+    end
+
     def get_culprit(frames)
-        lastframe = frames[-2]
-        "#{lastframe.filename} in #{lastframe.function}" if lastframe
+      lastframe = frames[-1]
+      "#{lastframe.filename} in #{lastframe.function}" if lastframe
     end
 
     def parse_exception(exception)
@@ -152,42 +177,12 @@ module Raven
       end
     end
 
-    def parse_backtrace_line(line, frame)
-      md = BACKTRACE_RE.match(line)
-      raise Error.new("Unable to parse backtrace line: #{line.inspect}") unless md
-      frame.abs_path = md[1]
-      frame.lineno = md[2].to_i
-      frame.function = md[3] if md[3]
-      frame.filename = strip_load_path_from(frame.abs_path)
-      if context_lines = @configuration[:context_lines]
-        frame.pre_context, frame.context_line, frame.post_context = \
-          get_context(frame.abs_path, frame.lineno, context_lines)
-      end
-      frame
-    end
-
     # For cross-language compat
     class << self
-      alias :captionException :capture_exception
+      alias :captureException :capture_exception
       alias :captureMessage :capture_message
     end
 
     private
-
-    # Because linecache can go to hell
-    def self._source_lines(path, from, to)
-    end
-
-    def get_context(path, line, context)
-      lines = (2 * context + 1).times.map do |i|
-        Raven::LineCache::getline(path, line - context + i)
-      end
-      [lines[0..(context-1)], lines[context], lines[(context+1)..-1]]
-    end
-
-    def strip_load_path_from(path)
-      prefix = $:.select {|s| path.start_with?(s)}.sort_by {|s| s.length}.last
-      prefix ? path[prefix.chomp(File::SEPARATOR).length+1..-1] : path
-    end
   end
 end

data/lib/raven/interfaces/stack_trace.rb

@@ -27,23 +27,29 @@ module Raven
     # Not actually an interface, but I want to use the same style
     class Frame < Interface
       property :abs_path
-      property :filename, :required => true
       property :function
       property :vars
       property :pre_context
       property :post_context
       property :context_line
       property :lineno, :required => true
+      property :in_app
 
       def initialize(*arguments)
-        self.vars= {}
+        self.vars = {}
         self.pre_context = []
         self.post_context = []
         super(*arguments)
       end
 
+      def filename
+        prefix = $:.select {|s| self.abs_path.start_with?(s)}.sort_by {|s| s.length}.last
+        prefix ? self.abs_path[prefix.chomp(File::SEPARATOR).length+1..-1] : self.abs_path
+      end
+
       def to_hash
         data = super
+        data['filename'] = self.filename
         data.delete('vars') unless self.vars && !self.vars.empty?
         data.delete('pre_context') unless self.pre_context && !self.pre_context.empty?
         data.delete('post_context') unless self.post_context && !self.post_context.empty?

data/lib/raven/sidekiq.rb

@@ -0,0 +1,18 @@
+module Raven
+  class Sidekiq
+    def call(worker, msg, queue)
+      begin
+        yield
+      rescue => ex
+        Raven.capture_exception(ex, :extra => {:sidekiq => msg})
+        raise
+      end
+    end
+  end
+end
+
+::Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add ::Raven::Sidekiq
+  end
+end

data/lib/raven/version.rb

@@ -1,3 +1,3 @@
 module Raven
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -4,17 +4,18 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Noah Kantrowitz
+- David Cramer
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-11-05 00:00:00 -08:00
+date: 2013-01-04 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,14 +23,13 @@ dependencies:
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 8
-        - 0
-        - rc2
-        version: 0.8.0.rc2
+        - 7
+        - 6
+        version: 0.7.6
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -71,14 +71,15 @@ dependencies:
   version_requirements: *id004
 description: 
 email: noah@coderanger.net
-executables: []
-
+executables: 
+- raven
 extensions: []
 
 extra_rdoc_files: 
 - README.md
 - LICENSE
 files: 
+- lib/raven/backtrace.rb
 - lib/raven/client.rb
 - lib/raven/configuration.rb
 - lib/raven/error.rb
@@ -95,6 +96,7 @@ files:
 - lib/raven/rack.rb
 - lib/raven/rails/middleware/debug_exceptions_catcher.rb
 - lib/raven/railtie.rb
+- lib/raven/sidekiq.rb
 - lib/raven/version.rb
 - lib/raven.rb
 - lib/sentry-raven.rb