mustwin-sentry-raven 0.11.2

data/lib/raven/processor.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Raven
+  class Processor
+    attr_accessor :sanitize_fields
+
+    def initialize(client)
+      @client = client
+      @sanitize_fields = client.configuration.sanitize_fields
+    end
+
+    def process(data)
+      data
+    end
+
+    private
+
+    def parse_json_or_nil(string)
+      begin
+        result = OkJson.decode(string)
+        result.is_a?(String) ? nil : result
+      rescue Raven::OkJson::Error
+        nil
+      end
+    end
+
+  end
+end

data/lib/raven/processor/removecircularreferences.rb

@@ -0,0 +1,17 @@
+module Raven
+  class Processor::RemoveCircularReferences < Processor
+
+    def process(v, visited = [])
+      return "(...)" if visited.include?(v.__id__)
+      visited += [v.__id__]
+      if v.is_a?(Hash)
+        v.reduce({}) { |memo, (k, v_)| memo[k] = process(v_, visited); memo }
+      elsif v.is_a?(Array)
+        v.map { |v_| process(v_, visited) }
+      else
+        v
+      end
+    end
+
+  end
+end

data/lib/raven/processor/sanitizedata.rb

@@ -0,0 +1,42 @@
+module Raven
+  class Processor::SanitizeData < Processor
+    STRING_MASK = '********'
+    INT_MASK = 0
+    DEFAULT_FIELDS = %w(authorization password passwd secret ssn social(.*)?sec)
+    VALUES_RE = /^\d{16}$/
+
+    def process(value)
+      fields_re = /(#{(DEFAULT_FIELDS + @sanitize_fields).join("|")})/i
+
+      value.inject(value) do |value,(k,v)|
+        v = k if v.nil?
+        if v.is_a?(Hash) || v.is_a?(Array)
+          process(v)
+        elsif v.is_a?(String) && (json = parse_json_or_nil(v))
+          #if this string is actually a json obj, convert and sanitize
+          value = modify_in_place(value, [k,v], process(json).to_json)
+        elsif v.is_a?(Integer) && (VALUES_RE.match(v.to_s) || fields_re.match(k.to_s))
+          value = modify_in_place(value, [k,v], INT_MASK)
+        elsif VALUES_RE.match(v.to_s) || fields_re.match(k.to_s)
+          value = modify_in_place(value, [k,v], STRING_MASK)
+        else
+          value
+        end
+      end
+      value
+    end
+
+    private
+
+    def modify_in_place(original_parent, original_child, new_child)
+      if original_parent.is_a?(Array)
+        index = original_parent.index(original_child[0])
+        original_parent[index] = new_child
+      elsif original_parent.is_a?(Hash)
+        original_parent[original_child[0]] = new_child
+      end
+      original_parent
+    end
+  end
+end
+

data/lib/raven/processor/utf8conversion.rb

@@ -0,0 +1,26 @@
+module Raven
+  class Processor::UTF8Conversion < Processor
+
+    def process(value)
+      if value.is_a? Array
+        value.map { |v_| process v_ }
+      elsif value.is_a? Hash
+        value.merge(value) { |k, v_| process v_ }
+      else
+        clean_invalid_utf8_bytes(value)
+      end
+    end
+
+    private
+
+    def clean_invalid_utf8_bytes(obj)
+      if obj.respond_to?(:to_utf8)
+        obj.to_utf8
+      elsif obj.respond_to?(:encoding)
+        obj.encode('UTF-16', :invalid => :replace, :undef => :replace, :replace => '').encode('UTF-8')
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/raven/rack.rb

@@ -0,0 +1,75 @@
+require 'time'
+
+module Raven
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Sentry and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'raven'
+  #
+  #   Raven.configure do |config|
+  #     config.server = 'http://my_dsn'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use Raven::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard Raven.configure call to configure your server credentials.
+  class Rack
+    def self.capture_exception(exception, env, options = {})
+      if env['requested_at']
+        options[:time_spent] = Time.now - env['requested_at']
+      end
+      Raven.capture_exception(exception, options) do |evt|
+        evt.interface :http do |int|
+          int.from_rack(env)
+        end
+      end
+    end
+
+    def self.capture_message(message, env, options = {})
+      if env['requested_at']
+        options[:time_spent] = Time.now - env['requested_at']
+      end
+      Raven.capture_message(message, options) do |evt|
+        evt.interface :http do |int|
+          int.from_rack(env)
+        end
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # clear context at the beginning of the request to ensure a clean slate
+      Context.clear!
+
+      # store the current environment in our local context for arbitrary
+      # callers
+      env['requested_at'] = Time.now
+      Raven.rack_context(env)
+
+      begin
+        response = @app.call(env)
+      rescue Error
+        raise # Don't capture Raven errors
+      rescue Exception => e
+        Raven.logger.debug "Collecting %p: %s" % [ e.class, e.message ]
+        Raven::Rack.capture_exception(e, env)
+        raise
+      end
+
+      error = env['rack.exception'] || env['sinatra.error']
+
+      Raven::Rack.capture_exception(error, env) if error
+
+      response
+    end
+  end
+end

data/lib/raven/rails/controller_methods.rb

@@ -0,0 +1,13 @@
+module Raven
+  module Rails
+    module ControllerMethods
+      def capture_message(message, options = {})
+        Raven::Rack.capture_message(message, request.env, options)
+      end
+
+      def capture_exception(exception, options = {})
+        Raven::Rack.capture_exception(exception, request.env, options)
+      end
+    end
+  end
+end

data/lib/raven/rails/middleware/debug_exceptions_catcher.rb

@@ -0,0 +1,16 @@
+module Raven
+  module Rails
+    module Middleware
+      module DebugExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :raven)
+        end
+
+        def render_exception_with_raven(env, exception)
+          Raven::Rack.capture_exception(exception, env)
+          render_exception_without_raven(env, exception)
+        end
+      end
+    end
+  end
+end

data/lib/raven/railtie.rb

@@ -0,0 +1,38 @@
+require 'raven'
+require 'rails'
+
+module Raven
+  class Railtie < ::Rails::Railtie
+    initializer "raven.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Raven::Rack"
+    end
+
+    initializer 'raven.action_controller' do
+      ActiveSupport.on_load :action_controller do
+        require 'raven/rails/controller_methods'
+        include Raven::Rails::ControllerMethods
+      end
+    end
+
+    config.after_initialize do
+      Raven.configure(true) do |config|
+        config.logger ||= ::Rails.logger
+        config.project_root ||= ::Rails.root
+      end
+
+      if Raven.configuration.catch_debugged_exceptions
+        if defined?(::ActionDispatch::DebugExceptions)
+          require 'raven/rails/middleware/debug_exceptions_catcher'
+          ::ActionDispatch::DebugExceptions.send(:include, Raven::Rails::Middleware::DebugExceptionsCatcher)
+        elsif defined?(::ActionDispatch::ShowExceptions)
+          require 'raven/rails/middleware/debug_exceptions_catcher'
+          ::ActionDispatch::ShowExceptions.send(:include, Raven::Rails::Middleware::DebugExceptionsCatcher)
+        end
+      end
+    end
+
+    rake_tasks do
+      require 'raven/tasks'
+    end
+  end
+end

data/lib/raven/rake.rb

@@ -0,0 +1,13 @@
+require 'raven'
+require 'rake/task'
+
+module Rake
+  class Application
+    alias :orig_display_error_messsage :display_error_message
+    def display_error_message(ex)
+      Raven.capture_exception ex, :logger => 'rake', :tags => { 'rake_task' => @name }
+      orig_display_error_messsage(ex)
+    end
+  end
+end
+

data/lib/raven/sidekiq.rb

@@ -0,0 +1,27 @@
+require 'time'
+
+module Raven
+  class Sidekiq
+    def call(worker, msg, queue)
+      started_at = Time.now
+      yield
+    rescue => ex
+      Raven.capture_exception(ex, :extra => { :sidekiq => msg },
+                                  :time_spent => Time.now-started_at)
+      raise
+    end
+  end
+end
+
+if Sidekiq::VERSION < '3'
+  # old behavior
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::Raven::Sidekiq
+    end
+  end
+else
+  Sidekiq.configure_server do |config|
+    config.error_handlers << Proc.new {|ex,context| Raven.capture_exception(ex, :extra => {:sidekiq => context}) }
+  end
+end

data/lib/raven/tasks.rb

@@ -0,0 +1,12 @@
+require 'rake'
+require 'raven'
+require 'raven/cli'
+
+namespace :raven do
+  desc "Send a test event to the remote Sentry server"
+  task :test, [:dsn] do |t, args|
+    Rake::Task["environment"].invoke if defined? Rails
+
+    Raven::CLI.test(args.dsn)
+  end
+end

data/lib/raven/transports.rb

@@ -0,0 +1,27 @@
+require 'raven/error'
+
+module Raven
+  module Transports
+    class Transport
+
+      attr_accessor :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def send(auth_header, data, options = {})
+        raise Error.new('Abstract method not implemented')
+      end
+
+      protected
+
+      def verify_configuration
+        raise Error.new('No server specified') unless self.configuration.server
+        raise Error.new('No public key specified') unless self.configuration.public_key
+        raise Error.new('No secret key specified') unless self.configuration.secret_key
+        raise Error.new('No project ID specified') unless self.configuration.project_id
+      end
+    end
+  end
+end

data/lib/raven/transports/http.rb

@@ -0,0 +1,56 @@
+require 'faraday'
+
+require 'raven/transports'
+require 'raven/error'
+
+module Raven
+  module Transports
+    class HTTP < Transport
+
+      def send(auth_header, data, options = {})
+        project_id = self.configuration[:project_id]
+        path = self.configuration[:path].gsub('/sentry', '') + "/"
+
+        response = conn.post "#{path}api/#{project_id}/store/" do |req|
+          req.headers['Content-Type'] = options[:content_type]
+          req.headers['X-Sentry-Auth'] = auth_header
+          req.body = data
+        end
+        Raven.logger.warn "Error from Sentry server (#{response.status}): #{response.body}" unless response.status == 200
+      end
+
+      private
+
+      def conn
+        @conn ||= begin
+          self.verify_configuration
+
+          Raven.logger.debug "Raven HTTP Transport connecting to #{self.configuration.server}"
+
+          ssl_configuration = self.configuration.ssl || {}
+          ssl_configuration[:verify] = self.configuration.ssl_verification
+
+          conn = Faraday.new(
+            :url => self.configuration[:server],
+            :ssl => ssl_configuration
+          ) do |builder|
+            builder.adapter(*adapter)
+          end
+
+          if self.configuration.timeout
+            conn.options[:timeout] = self.configuration.timeout
+          end
+          if self.configuration.open_timeout
+            conn.options[:open_timeout] = self.configuration.open_timeout
+          end
+
+          conn
+        end
+      end
+
+      def adapter
+        configuration.http_adapter || Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/raven/transports/udp.rb

@@ -0,0 +1,30 @@
+require 'socket'
+
+require 'raven/transports'
+require 'raven/error'
+
+module Raven
+  module Transports
+    class UDP < Transport
+
+      def send(auth_header, data, options = {})
+        conn.send "#{auth_header}\n\n#{data}", 0
+      end
+
+    private
+
+      def conn
+        @conn ||= begin
+          sock = UDPSocket.new
+          sock.connect(self.configuration.host, self.configuration.port)
+          sock
+        end
+      end
+
+      def verify_configuration
+        super
+        raise Error.new('No port specified') unless self.configuration.port
+      end
+    end
+  end
+end

data/lib/raven/version.rb

@@ -0,0 +1,3 @@
+module Raven
+  VERSION = "0.11.2"
+end

data/lib/sentry-raven.rb

@@ -0,0 +1 @@
+require "raven"