opbeat 0.9.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 157acc9610fffbf878154cc1ba1e7312a9b1f77f
-  data.tar.gz: 50476185d45bfafca5ce68cb542e1abb0ffbef7b
+  metadata.gz: a7eb7b17e78cc8c9e7257b46b2c618c2d18b3ba0
+  data.tar.gz: a3927d888501b9806001a62724b24bb62ed70584
 SHA512:
-  metadata.gz: 5ca3600ea88cae6d689c4a22cd5f25cb56a6a7682d374401b7010066e508201d03eb8d03756af6c2be4023153ccad7e7d50f9ef323ff8647562d8d79b1fdef8c
-  data.tar.gz: 6a689d1070878453e1e4132c4a722177663c15f14c100dd3ee9d5c0c4f9ab5fc80d2fbb06f69bcf8a12d69ec7b5d4149ed0ea979e1cac3bbaa6d06f163809532
+  metadata.gz: 0564b45393548258cc052aff8d980b36f20577d674af39d83f11ca496edc40a4654a31d25164e07fb9eae998dd6bcea1b601dbd46c26e467179cbf362c64ce15
+  data.tar.gz: eb7013aea6c700e64308fd84c2d53424edd1a097b220c26df7af9375572b618d7c7a62b4a36951248c18179e6a95c20ea247a2b3cfc2d05308c217fe4badd0c5

data/README.md

@@ -216,7 +216,26 @@ Opbeat.configure do |config|
 end
 ```
 
+## Async Delivery
 
+When an error occurs, the notification is immediately sent to Opbeat.
+This will hold up the client HTTP request as long as the request to
+Opbeat is ongoing. Alternatively the agent can be configured to send
+notifications asynchronously.
+
+Example using a native Ruby `Thread`:
+
+```ruby
+Opbeat.configure do |config|
+  config.async = lambda { |event|
+    Thread.new { Opbeat.send(event) }
+  }
+end
+```
+
+Using this decoupled approach you can easily implement this into your
+existing background job infrastructure. The only requirement is that you
+at some point call the `Opbeat.send` method with the `event` object.
 
 ## Testing
 
@@ -225,9 +244,7 @@ $ bundle install
 $ rake spec
 ```
 
-
 ## Resources
 
 * [Bug Tracker](http://github.com/opbeat/opbeat_ruby/issues)
 * [Code](http://github.com/opbeat/opbeat_ruby)
-

data/lib/opbeat.rb

@@ -85,27 +85,38 @@ module Opbeat
         at_exit do
           if $!
             logger.debug "Caught a post-mortem exception: #{$!.inspect}"
-            self.captureException($!)
+            self.capture_exception($!)
           end
         end
       end
     end
 
-    def captureException(exception, options={})
-      evt = Event.capture_exception(exception, options)
-      send(evt) if evt
+    def capture_exception(exception, options={})
+      exception.set_backtrace caller unless exception.backtrace
+      if (evt = Event.from_exception(exception, options))
+        if self.configuration.async?
+          self.configuration.async.call(evt)
+        else
+          send(evt)
+        end
+      end
     end
 
-    def captureMessage(message, options={})
-      evt = Event.capture_message(message, options)
-      send(evt) if evt
+    def capture_message(message, options={})
+      if (evt = Event.from_message(message, caller, options))
+        if self.configuration.async?
+          self.configuration.async.call(evt)
+        else
+          send(evt)
+        end
+      end
     end
 
     def set_context(options={})
       Event.set_context(options)
     end
 
-    alias :capture_exception :captureException
-    alias :capture_message :captureMessage
+    alias :captureException :capture_exception
+    alias :captureMessage :capture_message
   end
 end

data/lib/opbeat/client.rb

@@ -39,42 +39,32 @@ module Opbeat
 
   class Client
 
-    PROTOCOL_VERSION = '1.0'
     USER_AGENT = "opbeat-ruby/#{Opbeat::VERSION}"
-    AUTH_HEADER_KEY = 'Authorization'
 
     attr_accessor :configuration
     attr_accessor :state
 
-    def initialize(configuration)
-      @configuration = configuration
-      @state = ClientState.new configuration
-      @processors = configuration.processors.map { |p| p.new(self) }
+    def initialize(conf)
+      raise Error.new('No server specified') unless conf.server
+      raise Error.new('No secret token specified') unless conf.secret_token
+      raise Error.new('No organization ID specified') unless conf.organization_id
+      raise Error.new('No app ID specified') unless conf.app_id
+
+      @configuration = conf
+      @state = ClientState.new conf
+      @processors = conf.processors.map { |p| p.new(self) }
+      @base_url = "#{conf.server}/api/v1/organizations/#{conf.organization_id}/apps/#{conf.app_id}"
+      @auth_header = 'Bearer ' + conf.secret_token
     end
 
     def conn
-      # Error checking
-      raise Error.new('No server specified') unless self.configuration[:server]
-      raise Error.new('No secret token specified') unless self.configuration[:secret_token]
-      raise Error.new('No organization ID specified') unless self.configuration[:organization_id]
-      raise Error.new('No app ID specified') unless self.configuration[:app_id]
-
-      Opbeat.logger.debug "Opbeat client connecting to #{self.configuration[:server]}"
-      @base_url = self.configuration[:server] + 
-                            "/api/v1/organizations/" +
-                            self.configuration[:organization_id] +
-                            "/apps/" + self.configuration[:app_id]
-      @conn ||=  Faraday.new(:url => @base_url, :ssl => {:verify => self.configuration.ssl_verification}) do |builder|
-        builder.adapter  Faraday.default_adapter
+      @conn ||= Faraday.new(@base_url) do |faraday|
+        Opbeat.logger.debug "Initializing connection to #{self.configuration.server}"
+        faraday.adapter Faraday.default_adapter
+        faraday.ssl[:verify] = self.configuration.ssl_verification
+        faraday.options[:timeout] = self.configuration.timeout if self.configuration.timeout
+        faraday.options[:open_timeout] = self.configuration.open_timeout if self.configuration.open_timeout
       end
-
-      @conn.options[:timeout] = self.configuration[:timeout]
-      @conn.options[:open_timeout] = self.configuration[:open_timeout]
-      @conn
-    end
-
-    def generate_auth_header(data)
-      'Bearer ' + self.configuration[:secret_token]
     end
 
     def encode(event)
@@ -90,12 +80,15 @@ module Opbeat
     def send(url_postfix, message)
       begin
         response = self.conn.post @base_url + url_postfix do |req|
-          req.headers['Content-Type'] = 'application/json'
           req.body = self.encode(message)
-          req.headers[AUTH_HEADER_KEY] = self.generate_auth_header(req.body)
-          req.headers["User-Agent"] = USER_AGENT
+          req.headers['Authorization'] = @auth_header
+          req.headers['Content-Type'] = 'application/json'
+          req.headers['Content-Length'] = req.body.bytesize.to_s
+          req.headers['User-Agent'] = USER_AGENT
         end
-        if !response.status.between?(200, 299)
+        if response.status.between?(200, 299)
+          Opbeat.logger.info "Event logged successfully at " + response.headers["location"]
+        else
           raise Error.new("Error from Opbeat server (#{response.status}): #{response.body}")
         end
       rescue
@@ -115,9 +108,9 @@ module Opbeat
       end
 
       # Set the organization ID correctly
-      event.organization = self.configuration[:organization_id]
-      event.app = self.configuration[:app_id]
-      Opbeat.logger.debug "Sending event #{event.id} to Opbeat"
+      event.organization = self.configuration.organization_id
+      event.app = self.configuration.app_id
+      Opbeat.logger.debug "Sending event to Opbeat"
       send("/errors/", event)
     end
 

data/lib/opbeat/configuration.rb

@@ -44,6 +44,9 @@ module Opbeat
 
     attr_accessor :user_controller_method
 
+    # Optional Proc to be used to send events asynchronously
+    attr_reader :async
+
     def initialize
       self.server = ENV['OPBEAT_SERVER'] || "https://opbeat.com"
       self.secret_token = ENV['OPBEAT_SECRET_TOKEN'] if ENV['OPBEAT_SECRET_TOKEN']
@@ -55,9 +58,11 @@ module Opbeat
       self.excluded_exceptions = []
       self.processors = [Opbeat::Processor::SanitizeData]
       self.timeout = 1
+      self.open_timeout = 1
       self.backoff_multiplier = 2
       self.ssl_verification = true
       self.user_controller_method = 'current_user'
+      self.async = false
     end
 
     # Allows config options to be read like a hash
@@ -75,5 +80,12 @@ module Opbeat
       environments.include? current_environment
     end
 
+    def async=(value)
+      raise ArgumentError.new("async must be callable (or false to disable)") unless (value == false || value.respond_to?(:call))
+      @async = value
+    end
+
+    alias_method :async?, :async
+
   end
 end

data/lib/opbeat/event.rb

@@ -94,7 +94,7 @@ module Opbeat
       data
     end
 
-    def self.capture_exception(exc, options={}, &block)
+    def self.from_exception(exc, options={}, &block)
       configuration = Opbeat.configuration
       if exc.is_a?(Opbeat::Error)
         # Try to prevent error reporting loops
@@ -110,20 +110,18 @@ module Opbeat
         evt.message = "#{exc.class.to_s}: #{exc.message}"
         evt.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) }
-            end
-            evt.culprit = evt.get_culprit(int.frames)
+        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) }
           end
+          evt.culprit = evt.get_culprit(int.frames)
         end
         block.call(evt) if block
       end
     end
 
-    def self.capture_rack_exception(exc, rack_env, options={}, &block)
-      capture_exception(exc, options) do |evt|
+    def self.from_rack_exception(exc, rack_env, options={}, &block)
+      from_exception(exc, options) do |evt|
         evt.interface :http do |int|
           int.from_rack(rack_env)
         end
@@ -141,8 +139,8 @@ module Opbeat
       end
     end
 
-    def self.capture_message(message, options={})
-      configuration ||= Opbeat.configuration
+    def self.from_message(message, stack, options={})
+      configuration = Opbeat.configuration
       options = self.merge_context(options)
       self.new(options, configuration) do |evt|
         evt.message = message
@@ -150,6 +148,11 @@ module Opbeat
         evt.interface :message do |int|
           int.message = message
         end
+        evt.interface :stack_trace do |int|
+          int.frames = stack.reverse.map do |trace_line|
+            int.frame {|frame| evt.parse_backtrace_line(trace_line, frame) }
+          end
+        end
       end
     end
 
@@ -191,12 +194,6 @@ module Opbeat
       @user[:username] = user_obj.send(:username) rescue nil
     end
 
-    # For cross-language compat
-    class << self
-      alias :captionException :capture_exception
-      alias :captureMessage :capture_message
-    end
-
     private
 
     def self.merge_context(options={})

data/lib/opbeat/integrations/delayed_job.rb

@@ -17,7 +17,7 @@ if defined?(Delayed)
 
             rescue Exception => exception
               # Log error to Opbeat
-              ::Opbeat.captureException(exception)
+              ::Opbeat.capture_exception(exception)
               # Make sure we propagate the failure!
               raise exception
             end

data/lib/opbeat/integrations/resque.rb

@@ -13,7 +13,7 @@ if defined?(Resque)
         # @param (see Resque::Failure::Base#save)
         # @return (see Resque::Failure::Base#save)
         def save
-          ::Opbeat.captureException(exception)
+          ::Opbeat.capture_exception(exception)
         end
       end
     end

data/lib/opbeat/integrations/sidekiq.rb

@@ -12,7 +12,7 @@ if defined? Sidekiq
             yield
           rescue Exception => ex
             raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
-            ::Opbeat.captureException(ex)
+            ::Opbeat.capture_exception(ex)
             raise
           end
         end
@@ -26,7 +26,7 @@ if defined? Sidekiq
         chain.add ::Opbeat::Integrations::Sidekiq
       end
     else
-      config.error_handlers << Proc.new { |ex, ctx| ::Opbeat.captureException(ex) }
+      config.error_handlers << Proc.new { |ex, ctx| ::Opbeat.capture_exception(ex) }
     end
   end
 end

data/lib/opbeat/rack.rb

@@ -28,7 +28,7 @@ module Opbeat
       rescue Error => e
         raise # Don't capture Opbeat errors
       rescue Exception => e
-        evt = Event.capture_rack_exception(e, env)
+        evt = Event.from_rack_exception(e, env)
         Opbeat.send(evt)
         raise
       end
@@ -36,7 +36,7 @@ module Opbeat
       error = env['rack.exception'] || env['sinatra.error']
 
       if error
-        evt = Event.capture_rack_exception(error, env)
+        evt = Event.from_rack_exception(error, env)
         Opbeat.send(evt) if evt
       end
 

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

@@ -8,7 +8,7 @@ module Opbeat
 
         def render_exception_with_opbeat(env, exception)
           begin
-            evt = Opbeat::Event.capture_rack_exception(exception, env)
+            evt = Opbeat::Event.from_rack_exception(exception, env)
             Opbeat.send(evt) if evt
           rescue
             ::Rails::logger.debug "Error capturing or sending exception #{$!}"

data/lib/opbeat/version.rb

@@ -1,3 +1,3 @@
 module Opbeat
-  VERSION = "0.9.2"
+  VERSION = "1.0.0"
 end

data/spec/opbeat/client_spec.rb

@@ -3,10 +3,12 @@ require 'opbeat'
 
 describe Opbeat::Client do
   before do
-
     @configuration = Opbeat::Configuration.new
     @configuration.environments = ["test"]
     @configuration.current_environment = :test
+    @configuration.secret_token = 'test'
+    @configuration.organization_id = 'test'
+    @configuration.app_id = 'test'
     @client = Opbeat::Client.new(@configuration)
     allow(@client).to receive(:send)
   end

data/spec/opbeat/event_spec.rb

@@ -2,13 +2,13 @@ require File::expand_path('../../spec_helper', __FILE__)
 require 'opbeat'
 
 describe Opbeat::Event do
-  describe '.capture_message' do
+  describe '.from_message' do
     let(:message) { 'This is a message' }
-    let(:hash) { Opbeat::Event.capture_message(message).to_hash }
+    let(:hash) { Opbeat::Event.from_message(message, caller).to_hash }
 
     context 'for a Message' do
       it 'returns an event' do
-        expect(Opbeat::Event.capture_message(message)).to be_a(Opbeat::Event)
+        expect(Opbeat::Event.from_message(message, caller)).to be_a(Opbeat::Event)
       end
 
       it "sets the message to the value passed" do
@@ -21,14 +21,18 @@ describe Opbeat::Event do
     end
   end
 
-  describe '.capture_exception' do
+  describe '.from_exception' do
     let(:message) { 'This is a message' }
-    let(:exception) { Exception.new(message) }
-    let(:hash) { Opbeat::Event.capture_exception(exception).to_hash }
+    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.capture_exception(exception)).to be_a(Opbeat::Event)
+        expect(Opbeat::Event.from_exception(exception)).to be_a(Opbeat::Event)
       end
 
       it "sets the message to the exception's message and type" do
@@ -56,7 +60,11 @@ describe Opbeat::Event do
       module Opbeat::Test
         class Exception < Exception; end
       end
-      let(:exception) { Opbeat::Test::Exception.new(message) }
+      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')
@@ -66,7 +74,7 @@ describe Opbeat::Event do
     context 'for a Opbeat::Error' do
       let(:exception) { Opbeat::Error.new }
       it 'does not create an event' do
-        expect(Opbeat::Event.capture_exception(exception)).to be_nil
+        expect(Opbeat::Event.from_exception(exception)).to be_nil
       end
     end
 
@@ -113,7 +121,7 @@ describe Opbeat::Event do
     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.capture_exception(exception).to_hash        
+        hash = Opbeat::Event.from_exception(exception).to_hash
         expect(hash['user']).to eq({:id => 99, :is_authenticated => true})
       end
     end
@@ -122,7 +130,7 @@ describe Opbeat::Event do
       it 'sends the context and is_authenticated' do
         extra_context = {:jobid => 99}
         Opbeat::Event.set_context(:extra => extra_context)
-        hash = Opbeat::Event.capture_exception(exception).to_hash        
+        hash = Opbeat::Event.from_exception(exception).to_hash
         expect(hash['extra']).to eq(extra_context)
       end
     end

data/spec/opbeat/integrations/delayed_job_spec.rb

@@ -22,9 +22,9 @@ end
 Delayed::Worker.backend = Delayed::Backend::Test::Job
 
 describe Delayed::Plugins::Opbeat do
-  it 'should call Opbeat::captureException on erronous jobs' do
+  it 'should call Opbeat::capture_exception on erronous jobs' do
     test_exception = Exception.new("Test exception")
-    expect(Opbeat).to receive(:captureException).with(test_exception)
+    expect(Opbeat).to receive(:capture_exception).with(test_exception)
 
     # Queue
     bomb = Bomb.new

data/spec/opbeat/opbeat_spec.rb

@@ -6,34 +6,59 @@ describe Opbeat do
     @send = double("send")
     @event = double("event")
     allow(Opbeat).to receive(:send) { @send }
-    allow(Opbeat::Event).to receive(:capture_message) { @event }
-    allow(Opbeat::Event).to receive(:capture_exception) { @event }
+    allow(Opbeat::Event).to receive(:from_message) { @event }
+    allow(Opbeat::Event).to receive(:from_exception) { @event }
   end
 
-  it 'captureMessage should send result of Event.capture_message' do
+  it 'capture_message should send result of Event.from_message' do
     message = "Test message"
-    expect(Opbeat::Event).to receive(:capture_message).with(message, {})
+    expect(Opbeat::Event).to receive(:from_message).with(message, an_instance_of(Array), {})
     expect(Opbeat).to receive(:send).with(@event)
 
-    Opbeat.captureMessage(message)
+    Opbeat.capture_message(message)
   end
 
-  it 'captureMessage with options should send result of Event.capture_message' do
+  it 'capture_message with options should send result of Event.from_message' do
     message = "Test message"
     options = {:extra => {:hello => "world"}}
-    expect(Opbeat::Event).to receive(:capture_message).with(message, options)
+    expect(Opbeat::Event).to receive(:from_message).with(message, an_instance_of(Array), options)
     expect(Opbeat).to receive(:send).with(@event)
 
-    Opbeat.captureMessage(message, options)
+    Opbeat.capture_message(message, options)
   end
 
-  it 'captureException should send result of Event.capture_exception' do
+  it 'capture_exception should send result of Event.from_exception' do
     exception = build_exception()
 
-    expect(Opbeat::Event).to receive(:capture_exception).with(exception, {})
+    expect(Opbeat::Event).to receive(:from_exception).with(exception, {})
     expect(Opbeat).to receive(:send).with(@event)
 
-    Opbeat.captureException(exception)
+    Opbeat.capture_exception(exception)
   end
 
+  context "async" do
+    it 'capture_message should send result of Event.from_message' do
+      async = lambda {}
+      message = "Test message"
+
+      expect(Opbeat::Event).to receive(:from_message).with(message, an_instance_of(Array), {})
+      expect(Opbeat).to_not receive(:send)
+      expect(async).to receive(:call).with(@event)
+
+      Opbeat.configuration.async = async
+      Opbeat.capture_message(message)
+    end
+
+    it 'capture_exception should send result of Event.from_exception' do
+      async = lambda {}
+      exception = build_exception()
+
+      expect(Opbeat::Event).to receive(:from_exception).with(exception, {})
+      expect(Opbeat).to_not receive(:send)
+      expect(async).to receive(:call).with(@event)
+
+      Opbeat.configuration.async = async
+      Opbeat.capture_exception(exception)
+    end
+  end
 end

data/spec/opbeat/rack_spec.rb

@@ -35,14 +35,14 @@ describe Opbeat::Rack do
     @send = double("send")
     @event = double("event")
     allow(Opbeat).to receive(:send) { @send }
-    allow(Opbeat::Event).to receive(:capture_rack_exception) { @event }
+    allow(Opbeat::Event).to receive(:from_rack_exception) { @event }
   end
 
   it 'should capture exceptions' do
     exception = build_exception()
     env = {}
     
-    expect(Opbeat::Event).to receive(:capture_rack_exception).with(exception, env)
+    expect(Opbeat::Event).to receive(:from_rack_exception).with(exception, env)
     expect(Opbeat).to receive(:send).with(@event)
 
     app = lambda do |e|
@@ -57,7 +57,7 @@ describe Opbeat::Rack do
     exception = build_exception()
     env = {}
 
-    expect(Opbeat::Event).to receive(:capture_rack_exception).with(exception, env)
+    expect(Opbeat::Event).to receive(:from_rack_exception).with(exception, env)
     expect(Opbeat).to receive(:send).with(@event)
 
     app = lambda do |e|
@@ -84,7 +84,7 @@ describe Opbeat::Rack do
   it 'should extract user info' do
     expected_user = TestController.new.current_user
 
-    Opbeat::Event.capture_rack_exception(@exception, @env) do |event|
+    Opbeat::Event.from_rack_exception(@exception, @env) do |event|
       user = event.to_hash['user']
       expect(user[:id]).to eq(expected_user.id)
       expect(user[:email]).to eq(expected_user.email)
@@ -97,7 +97,7 @@ describe Opbeat::Rack do
     Opbeat.configuration.user_controller_method = :custom_user
     expected_user = TestController.new.custom_user
 
-    Opbeat::Event.capture_rack_exception(@exception, @env) do |event|
+    Opbeat::Event.from_rack_exception(@exception, @env) do |event|
       user = event.to_hash['user']
       expect(user[:id]).to eq(expected_user.id)
       expect(user[:email]).to eq(expected_user.email)
@@ -110,7 +110,7 @@ describe Opbeat::Rack do
     Opbeat.configuration.user_controller_method = :missing_user_method
     expected_user = TestController.new.custom_user
 
-    Opbeat::Event.capture_rack_exception(@exception, @env) do |event|
+    Opbeat::Event.from_rack_exception(@exception, @env) do |event|
       expect(event.user).to eq(nil)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opbeat
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Thomas Watson Steen
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-08 00:00:00.000000000 Z
+date: 2015-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday