mustwin-sentry-raven 0.11.2

data/lib/raven/context.rb

@@ -0,0 +1,21 @@
+module Raven
+  class Context
+    def self.current
+      Thread.current[:sentry_context] ||= new
+    end
+
+    def self.clear!
+      Thread.current[:sentry_context] = nil
+    end
+
+    attr_reader :extra, :tags
+    attr_accessor :rack_env, :user
+
+    def initialize
+      @extra = {}
+      @tags = {}
+      @user = {}
+      @rack_env = nil
+    end
+  end
+end

data/lib/raven/error.rb

@@ -0,0 +1,4 @@
+module Raven
+  class Error < StandardError
+  end
+end

data/lib/raven/event.rb

@@ -0,0 +1,223 @@
+require 'rubygems'
+require 'socket'
+require 'securerandom'
+
+require 'raven/error'
+require 'raven/linecache'
+
+module Raven
+
+  class Event
+
+    LOG_LEVELS = {
+      "debug" => 10,
+      "info" => 20,
+      "warn" => 30,
+      "warning" => 30,
+      "error" => 40,
+      "fatal" => 50,
+    }
+
+    BACKTRACE_RE = /^(.+?):(\d+)(?::in `(.+?)')?$/
+
+    PLATFORM = "ruby"
+
+    attr_reader :id
+    attr_accessor :project, :message, :timestamp, :time_spent, :level
+    attr_accessor :logger, :culprit, :server_name, :modules, :extra, :tags
+
+    def initialize(options = {}, &block)
+      @configuration = options[:configuration] || Raven.configuration
+      @interfaces = {}
+
+      context = options[:context] || Raven.context
+
+      @id = options[:id] || generate_event_id
+      @message = options[:message]
+      @timestamp = options[:timestamp] || Time.now.utc
+      @time_spent = options[:time_spent]
+
+      @level = options[:level] || :error
+      @logger = options[:logger] || 'root'
+      @culprit = options[:culprit]
+      @server_name = options[:server_name] || @configuration.server_name || get_hostname
+
+      options[:modules] ||= get_modules if @configuration.send_modules
+
+      @modules = options[:modules]
+
+      @user = options[:user] || {}
+      @user.merge!(context.user) if context.respond_to?(:user)
+
+      @extra = options[:extra] || {}
+      @extra.merge!(context.extra) if context.respond_to?(:extra)
+
+      @tags = @configuration.tags
+      @tags.merge!(options[:tags] || {})
+      @tags.merge!(context.tags) if context.respond_to?(:tags)
+
+      block.call(self) if block
+
+      if @configuration.send_in_current_environment?
+        if !self[:http] && context.rack_env
+          self.interface :http do |int|
+            int.from_rack(context.rack_env)
+          end
+        end
+      end
+
+      # Some type coercion
+      @timestamp = @timestamp.strftime('%Y-%m-%dT%H:%M:%S') if @timestamp.is_a?(Time)
+      @time_spent = (@time_spent*1000).to_i if @time_spent.is_a?(Float)
+      @level = LOG_LEVELS[@level.to_s.downcase] if @level.is_a?(String) || @level.is_a?(Symbol)
+    end
+
+    def get_hostname
+      # Try to resolve the hostname to an FQDN, but fall back to whatever the load name is
+      hostname = Socket.gethostname
+      hostname = Socket.gethostbyname(hostname).first rescue hostname
+    end
+
+    def get_modules
+      # Older versions of Rubygems don't support iterating over all specs
+      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
+    end
+
+    def interface(name, value = nil, &block)
+      int = Raven.find_interface(name)
+      raise Error.new("Unknown interface: #{name}") unless int
+      @interfaces[int.name] = int.new(value, &block) if value || block
+      @interfaces[int.name]
+    end
+
+    def [](key)
+      interface(key)
+    end
+
+    def []=(key, value)
+      interface(key, value)
+    end
+
+    def to_hash
+      data = {
+        'event_id' => @id,
+        'message' => @message,
+        'timestamp' => @timestamp,
+        'time_spent' => @time_spent,
+        'level' => @level,
+        'project' => @project,
+        'logger' => @logger,
+        'platform' => PLATFORM,
+      }
+      data['culprit'] = @culprit if @culprit
+      data['server_name'] = @server_name if @server_name
+      data['modules'] = @modules if @modules
+      data['extra'] = @extra if @extra
+      data['tags'] = @tags if @tags
+      data['user'] = @user if @user
+      @interfaces.each_pair do |name, int_data|
+        data[name] = int_data.to_hash
+      end
+      data
+    end
+
+    def self.from_exception(exc, options = {}, &block)
+      notes = exc.instance_variable_get(:@__raven_context) || {}
+      options = notes.merge(options)
+
+      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].any? { |x| (x === exc rescue false) || x == exc.class.name }
+        Raven.logger.info "User excluded error: #{exc.inspect}"
+        return nil
+      end
+
+      context_lines = configuration[:context_lines]
+
+      new(options) do |evt|
+        evt.message = "#{exc.class.to_s}: #{exc.message}"
+        evt.level = options[:level] || :error
+
+        evt.interface(:exception) do |int|
+          int.type = exc.class.to_s
+          int.value = exc.to_s
+          int.module = exc.class.to_s.split('::')[0...-1].join('::')
+
+          # TODO(dcramer): this needs cleaned up, but I couldn't figure out how to
+          # work Hashie as a non-Rubyist
+          if exc.backtrace
+            int.stacktrace = StacktraceInterface.new do |stacktrace|
+              backtrace = Backtrace.parse(exc.backtrace)
+              stacktrace.frames = backtrace.lines.reverse.map do |line|
+                stacktrace.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.abs_path
+                    frame.pre_context, frame.context_line, frame.post_context = \
+                      evt.get_file_context(frame.abs_path, frame.lineno, context_lines)
+                  end
+                end
+              end.select { |f| f.filename }
+
+              evt.culprit = evt.get_culprit(stacktrace.frames)
+            end
+          end
+        end
+
+        block.call(evt) if block
+      end
+    end
+
+    def self.from_message(message, options = {})
+      new(options) do |evt|
+        evt.message = message
+        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_file_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.reverse.find { |f| f.in_app } || frames.last
+      "#{lastframe.filename} in #{lastframe.function} at line #{lastframe.lineno}" if lastframe
+    end
+
+    # For cross-language compat
+    class << self
+      alias :captureException :from_exception
+      alias :captureMessage :from_message
+      alias :capture_exception :from_exception
+      alias :capture_message :from_message
+    end
+
+    private
+
+    def generate_event_id
+      # generate a uuid. copy-pasted from SecureRandom, this method is not
+      # available in <1.9.
+      ary = SecureRandom.random_bytes(16).unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0fff) | 0x4000
+      ary[3] = (ary[3] & 0x3fff) | 0x8000
+      uuid = "%08x-%04x-%04x-%04x-%04x%08x" % ary
+      Digest::MD5.hexdigest(uuid)
+    end
+  end
+end

data/lib/raven/integrations/delayed_job.rb

@@ -0,0 +1,49 @@
+require 'delayed_job'
+
+module Delayed
+  module Plugins
+
+    class Raven < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            # Forward the call to the next callback in the callback chain
+            block.call(job, *args)
+
+          rescue Exception => exception
+            # Log error to Sentry
+            ::Raven.capture_exception(exception,
+              :logger  => 'delayed_job',
+              :tags    => {
+                 :delayed_job_queue => job.queue
+              },
+              :extra => {
+                  :delayed_job => {
+                      :id          => job.id,
+                      :priority    => job.priority,
+                      :attempts    => job.attempts,
+                      :handler     => job.handler,
+                      :last_error  => job.last_error,
+                      :run_at      => job.run_at,
+                      :locked_at   => job.locked_at,
+                      #failed_at  => job.failed_at,
+                      :locked_by   => job.locked_by,
+                      :queue       => job.queue,
+                      :created_at  => job.created_at
+                  }
+              })
+
+            # Make sure we propagate the failure!
+            raise exception
+          end
+        end
+      end
+    end
+
+  end
+end
+
+##
+# Register DelayedJob Raven plugin
+#
+Delayed::Worker.plugins << Delayed::Plugins::Raven

data/lib/raven/interfaces.rb

@@ -0,0 +1,34 @@
+require 'raven/better_attr_accessor'
+
+module Raven
+
+  INTERFACES = {}
+
+  class Interface
+    include BetterAttrAccessor
+    alias_method :to_hash, :attributes
+
+    def initialize(attributes = nil)
+      attributes.each do |attr, value|
+        send "#{attr}=", value
+      end if attributes
+
+      yield self if block_given?
+    end
+
+    def self.name(value = nil)
+      @interface_name ||= value
+    end
+  end
+
+  def self.register_interface(mapping)
+    mapping.each_pair do |key, klass|
+      INTERFACES[key.to_s] = klass
+      INTERFACES[klass.name] = klass
+    end
+  end
+
+  def self.find_interface(name)
+    INTERFACES[name.to_s]
+  end
+end

data/lib/raven/interfaces/exception.rb

@@ -0,0 +1,22 @@
+require 'raven/interfaces'
+
+module Raven
+  class ExceptionInterface < Interface
+
+    name 'exception'
+    attr_accessor :type
+    attr_accessor :value
+    attr_accessor :module
+    attr_accessor :stacktrace
+
+    def to_hash(*args)
+      data = super(*args)
+      if data['stacktrace']
+        data['stacktrace'] = data['stacktrace'].to_hash
+      end
+      data
+    end
+  end
+
+  register_interface :exception => ExceptionInterface
+end

data/lib/raven/interfaces/http.rb

@@ -0,0 +1,53 @@
+require 'raven/interfaces'
+
+module Raven
+  class HttpInterface < Interface
+
+    name 'request'
+    attr_accessor :url
+    attr_accessor :method
+    attr_accessor :data
+    attr_accessor :query_string
+    attr_accessor :cookies
+    attr_accessor :headers
+    attr_accessor :env
+
+    def initialize(*arguments)
+      self.headers = {}
+      self.env = {}
+      super(*arguments)
+    end
+
+    def from_rack(env)
+      require 'rack'
+      req = ::Rack::Request.new(env)
+      self.url = req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+      env.each_pair do |key, value|
+        next unless key.upcase == key # Non-upper case stuff isn't either
+        if key.start_with?('HTTP_')
+          # Header
+          http_key = key[5..key.length - 1].split('_').map { |s| s.capitalize }.join('-')
+          self.headers[http_key] = value.to_s
+        elsif ['CONTENT_TYPE', 'CONTENT_LENGTH'].include? key
+          self.headers[key.capitalize] = value.to_s
+        elsif ['REMOTE_ADDR', 'SERVER_NAME', 'SERVER_PORT'].include? key
+          # Environment
+          self.env[key] = value.to_s
+        end
+      end
+
+      self.data =
+        if req.form_data?
+          req.POST
+        elsif req.body
+          data = req.body.read
+          req.body.rewind
+          data
+        end
+    end
+  end
+
+  register_interface :http => HttpInterface
+end

data/lib/raven/interfaces/message.rb

@@ -0,0 +1,17 @@
+require 'raven/interfaces'
+
+module Raven
+  class MessageInterface < Interface
+
+    name 'sentry.interfaces.Message'
+    attr_accessor :message
+    attr_accessor :params
+
+    def initialize(*arguments)
+      self.params = []
+      super(*arguments)
+    end
+  end
+
+  register_interface :message => MessageInterface
+end

data/lib/raven/interfaces/stack_trace.rb

@@ -0,0 +1,55 @@
+require 'raven/interfaces'
+
+module Raven
+  class StacktraceInterface < Interface
+
+    name 'stacktrace'
+    attr_accessor :frames, :default => []
+
+    def initialize(*arguments)
+      self.frames = []
+      super(*arguments)
+    end
+
+    def to_hash(*args)
+      data = super(*args)
+      data['frames'] = data['frames'].map { |frame| frame.to_hash }
+      data
+    end
+
+    def frame(attributes = nil, &block)
+      Frame.new(attributes, &block)
+    end
+
+    # Not actually an interface, but I want to use the same style
+    class Frame < Interface
+      attr_accessor :abs_path
+      attr_accessor :function
+      attr_accessor :vars,         :default => []
+      attr_accessor :pre_context,  :default => []
+      attr_accessor :post_context, :default => []
+      attr_accessor :context_line
+      attr_accessor :lineno
+      attr_accessor :in_app
+
+      def filename
+        return nil if self.abs_path.nil?
+
+        prefix = $LOAD_PATH.select { |s| self.abs_path.start_with?(s.to_s) }.sort_by { |s| s.to_s.length }.last
+        prefix ? self.abs_path[prefix.to_s.chomp(File::SEPARATOR).length+1..-1] : self.abs_path
+      end
+
+      def to_hash(*args)
+        data = super(*args)
+        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.delete('context_line') unless self.context_line && !self.context_line.empty?
+        data
+      end
+    end
+  end
+
+  register_interface :stack_trace => StacktraceInterface
+end