opbeat 2.0.0 → 3.0.0

data/lib/opbeat/interfaces/exception.rb

@@ -1,16 +0,0 @@
-require 'opbeat/interfaces'
-
-module Opbeat
-
-  class ExceptionInterface < Interface
-
-    name 'exception'
-    attr_accessor :type
-    attr_accessor :value
-    attr_accessor :module
-
-  end
-
-  register_interface :exception => ExceptionInterface
-
-end

data/lib/opbeat/interfaces/http.rb

@@ -1,57 +0,0 @@
-require 'opbeat/interfaces'
-
-module Opbeat
-
-  class HttpInterface < Interface
-
-    name 'http'
-    attr_accessor :url
-    attr_accessor :method
-    attr_accessor :data
-    attr_accessor :query_string
-    attr_accessor :cookies
-    attr_accessor :headers
-    attr_accessor :remote_host
-    attr_accessor :http_host
-    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
-      self.cookies = req.cookies.collect {|k,v| "#{k}=#{v}"}.join(';')
-      self.remote_host = req.ip
-      self.http_host = req.host_with_port
-      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
-        else
-          # 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/opbeat/interfaces/message.rb

@@ -1,19 +0,0 @@
-require 'opbeat/interfaces'
-
-module Opbeat
-
-  class MessageInterface < Interface
-
-    name 'param_message'
-    attr_accessor :message
-    attr_accessor :params
-
-    def initialize(*arguments)
-      self.params = []
-      super(*arguments)
-    end
-  end
-
-  register_interface :message => MessageInterface
-
-end

data/lib/opbeat/interfaces/stack_trace.rb

@@ -1,50 +0,0 @@
-require 'opbeat/interfaces'
-
-module Opbeat
-
-  class StacktraceInterface < Interface
-
-    name 'stacktrace'
-    attr_accessor :frames, :default => []
-
-    def initialize(*arguments)
-      self.frames = []
-      super(*arguments)
-    end
-
-    def to_hash
-      data = super
-      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 :filename
-      attr_accessor :function
-      attr_accessor :vars, :default => {}
-      attr_accessor :pre_context, :default => []
-      attr_accessor :post_context, :default => []
-      attr_accessor :context_line
-      attr_accessor :lineno
-
-      def to_hash
-        data = super
-        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

data/lib/opbeat/linecache.rb

@@ -1,25 +0,0 @@
-# A much simpler source line cacher because linecache sucks at platform compat
-
-module Opbeat
-
-  class LineCache
-    class << self
-      CACHE = {}
-
-      def getlines(path)
-        CACHE[path] ||= begin
-          IO.readlines(path)
-        rescue
-          []
-        end
-      end
-
-      def getline(path, n)
-        return nil if n < 1
-        getlines(path)[n-1]
-      end
-
-    end
-  end
-
-end

data/lib/opbeat/logger.rb

@@ -1,21 +0,0 @@
-module Opbeat
-  class Logger
-    LOG_PREFIX = "** [Opbeat] "
-
-    [
-      :fatal,
-      :error,
-      :warn,
-      :info,
-      :debug,
-    ].each do |level|
-      define_method level do |*args, &block|
-        msg = args[0] # Block-level default args is a 1.9 feature
-        msg ||= block.call if block
-        logger = Opbeat.configuration[:logger]
-        logger.send(level, "#{LOG_PREFIX}#{msg}") if logger
-      end
-    end
-
-  end
-end

data/lib/opbeat/rack.rb

@@ -1,46 +0,0 @@
-module Opbeat
-  # Middleware for Rack applications. Any errors raised by the upstream
-  # application will be delivered to Opbeat and re-raised.
-  #
-  # Synopsis:
-  #
-  #   require 'rack'
-  #   require 'opbeat'
-  #
-  #   Opbeat.configure do |config|
-  #     config.server = 'http://my_dsn'
-  #   end
-  #
-  #   app = Rack::Builder.app do
-  #     use Opbeat::Rack
-  #     run lambda { |env| raise "Rack down" }
-  #   end
-  #
-  # Use a standard Opbeat.configure call to configure your server credentials.
-  class Rack
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      begin
-        response = @app.call(env)
-      rescue Error => e
-        raise # Don't capture Opbeat errors
-      rescue Exception => e
-        evt = Event.from_rack_exception(e, env)
-        Opbeat.send(evt)
-        raise
-      end
-
-      error = env['rack.exception'] || env['sinatra.error']
-
-      if error
-        evt = Event.from_rack_exception(error, env)
-        Opbeat.send(evt) if evt
-      end
-
-      response
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Opbeat
-  module Rails
-    module Middleware
-      module DebugExceptionsCatcher
-        def self.included(base)
-          base.send(:alias_method_chain, :render_exception, :opbeat)
-        end
-
-        def render_exception_with_opbeat(env, exception)
-          begin
-            evt = Opbeat::Event.from_rack_exception(exception, env)
-            Opbeat.send(evt) if evt
-          rescue
-            ::Rails::logger.debug "Error capturing or sending exception #{$!}"
-          end
-
-          render_exception_without_opbeat(env, exception)
-        end
-      end
-    end
-  end
-end

data/lib/opbeat/railtie.rb

@@ -1,26 +0,0 @@
-require 'opbeat'
-require 'rails'
-
-module Opbeat
-  class Railtie < ::Rails::Railtie
-    initializer "opbeat.use_rack_middleware" do |app|
-      app.config.middleware.insert 0, "Opbeat::Rack"
-    end
-    config.after_initialize do
-      Opbeat.configure(true) do |config|
-        config.logger ||= ::Rails.logger
-      end
-
-      if defined?(::ActionDispatch::DebugExceptions)
-        require 'opbeat/rails/middleware/debug_exceptions_catcher'
-        ::ActionDispatch::DebugExceptions.send(:include, Opbeat::Rails::Middleware::DebugExceptionsCatcher)
-      elsif defined?(::ActionDispatch::ShowExceptions)
-        require 'opbeat/rails/middleware/debug_exceptions_catcher'
-        ::ActionDispatch::ShowExceptions.send(:include, Opbeat::Rails::Middleware::DebugExceptionsCatcher)
-      end
-    end
-    rake_tasks do
-      require 'opbeat/tasks'
-    end
-  end
-end

data/spec/opbeat/better_attr_accessor_spec.rb

@@ -1,99 +0,0 @@
-require File::expand_path('../../spec_helper', __FILE__)
-require 'opbeat'
-
-describe Opbeat::BetterAttrAccessor do
-
-  let :klass do
-    Class.new do
-      include Opbeat::BetterAttrAccessor
-
-      attr_accessor :a
-      attr_accessor :b, :default => []
-      attr_accessor :c
-    end
-  end
-
-  let :child do
-    Class.new klass do
-      attr_accessor :d
-    end
-  end
-
-  subject{ klass.new }
-
-  describe 'the reader method' do
-    context 'when a value is not set' do
-      it 'should default to nil' do
-        expect(subject.a).to eq nil
-      end
-      it 'should use a default value if provided' do
-        expect(subject.b).to eq []
-        expect(subject.instance_variable_get '@b').to eq []
-      end
-    end
-
-    context 'when a value is set' do
-      before do
-        subject.a = 'foo'
-        subject.b = :bar
-        subject.c = false
-      end
-
-      it 'should save the value' do
-        expect(subject.a).to eq 'foo'
-      end
-      it 'should save a boolean `false` value' do
-        expect(subject.c).to eq false
-      end
-      it 'should no longer return the default' do
-        expect(subject.b).to eq :bar
-      end
-    end
-
-    context 'when a default value is directly modified' do
-      before { subject.b << 9 }
-      it 'should not affect a new instance' do
-        expect(klass.new.b).to eq []
-      end
-    end
-  end
-
-  describe '.attributes' do
-    it 'should be a Set of all attributes set up' do
-      expect(klass.attributes).to be_a Set
-      expect(klass.attributes).to eq %w[a b c].to_set
-    end
-    it 'should work with inheritance' do
-      expect(child.attributes).to eq %w[d a b c].to_set
-    end
-  end
-
-  describe '#attributes' do
-    it 'should return a hash of all attributes' do
-      subject.a = {'foo' => :bar}
-      subject.b << 8
-      expect(subject.attributes).to eq \
-        'a' => {'foo' => :bar},
-        'b' => [8],
-        'c' => nil
-    end
-
-    describe 'inheritance' do
-      subject{ child.new }
-
-      before do
-        subject.a = 21
-        subject.d = true
-      end
-
-      it 'should work' do
-        expect(subject.attributes).to eq \
-          'a' => 21,
-          'b' => [],
-          'c' => nil,
-          'd' => true
-      end
-    end
-  end
-
-end

data/spec/opbeat/event_spec.rb

@@ -1,138 +0,0 @@
-require File::expand_path('../../spec_helper', __FILE__)
-require 'opbeat'
-
-describe Opbeat::Event do
-  describe '.from_message' do
-    let(:message) { 'This is a message' }
-    let(:hash) { Opbeat::Event.from_message(message, caller).to_hash }
-
-    context 'for a Message' do
-      it 'returns an event' do
-        expect(Opbeat::Event.from_message(message, caller)).to be_a(Opbeat::Event)
-      end
-
-      it "sets the message to the value passed" do
-        expect(hash['message']).to eq(message)
-      end
-
-      it 'has level ERROR' do
-        expect(hash['level']).to eq('error')
-      end
-    end
-  end
-
-  describe '.from_exception' do
-    let(:message) { 'This is a message' }
-    let(:exception) {
-      exc = Exception.new(message)
-      exc.set_backtrace caller
-      exc
-    }
-    let(:hash) { Opbeat::Event.from_exception(exception).to_hash }
-
-    context 'for an Exception' do
-      it 'returns an event' do
-        expect(Opbeat::Event.from_exception(exception)).to be_a(Opbeat::Event)
-      end
-
-      it "sets the message to the exception's message and type" do
-        expect(hash['message']).to eq("Exception: #{message}")
-      end
-
-      it 'has level ERROR' do
-        expect(hash['level']).to eq('error')
-      end
-
-      it 'uses the exception class name as the exception type' do
-        expect(hash['exception']['type']).to eq('Exception')
-      end
-
-      it 'uses the exception message as the exception value' do
-        expect(hash['exception']['value']).to eq(message)
-      end
-
-      it 'does not belong to a module' do
-        expect(hash['exception']['module']).to eq('')
-      end
-    end
-
-    context 'for a nested exception type' do
-      module Opbeat::Test
-        class Exception < Exception; end
-      end
-      let(:exception) {
-        exc = Opbeat::Test::Exception.new(message)
-        exc.set_backtrace caller
-        exc
-      }
-
-      it 'sends the module name as part of the exception info' do
-        expect(hash['exception']['module']).to eq('Opbeat::Test')
-      end
-    end
-
-    context 'for a Opbeat::Error' do
-      let(:exception) { Opbeat::Error.new }
-      it 'does not create an event' do
-        expect(Opbeat::Event.from_exception(exception)).to be_nil
-      end
-    end
-
-    context 'when the exception has a backtrace' do
-      let(:exception) do
-        e = Exception.new(message)
-        allow(e).to receive(:backtrace).and_return([
-          "/path/to/some/file:22:in `function_name'",
-          "/some/other/path:1412:in `other_function'",
-        ])
-        e
-      end
-
-      it 'parses the backtrace' do
-        expect(hash['stacktrace']['frames'].length).to eq(2)
-        expect(hash['stacktrace']['frames'][0]['lineno']).to eq(1412)
-        expect(hash['stacktrace']['frames'][0]['function']).to eq('other_function')
-        expect(hash['stacktrace']['frames'][0]['filename']).to eq('/some/other/path')
-
-        expect(hash['stacktrace']['frames'][1]['lineno']).to eq(22)
-        expect(hash['stacktrace']['frames'][1]['function']).to eq('function_name')
-        expect(hash['stacktrace']['frames'][1]['filename']).to eq('/path/to/some/file')
-      end
-
-      it "sets the culprit" do
-        expect(hash['culprit']).to eq("/some/other/path in other_function")
-      end
-
-      context 'when a path in the stack trace is on the laod path' do
-        before do
-          $LOAD_PATH << '/some'
-        end
-
-        after do
-          $LOAD_PATH.delete('/some')
-        end
-
-        it 'strips prefixes in the load path from frame filenames' do
-          expect(hash['stacktrace']['frames'][0]['filename']).to eq('other/path')
-        end
-      end
-    end
-
-    context 'when there is user context' do
-      it 'sends the context and is_authenticated' do
-        Opbeat::Event.set_context(:user => {:id => 99})
-        hash = Opbeat::Event.from_exception(exception).to_hash
-        expect(hash['user']).to eq({:id => 99, :is_authenticated => true})
-      end
-    end
-
-    context 'when there is extra context' do
-      it 'sends the context and is_authenticated' do
-        extra_context = {:jobid => 99}
-        Opbeat::Event.set_context(:extra => extra_context)
-        hash = Opbeat::Event.from_exception(exception).to_hash
-        expect(hash['extra']).to eq(extra_context)
-      end
-    end
-  end
-end