opbeat 2.0.0 → 3.0.0

data/spec/opbeat/http_client_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module Opbeat
+  describe HttpClient do
+
+    let(:configuration) do
+      Configuration.new do |c|
+        c.secret_token = 'TOKEN'
+        c.organization_id = 'ORG'
+        c.app_id = 'APP'
+      end
+    end
+    let(:http_client) do
+      HttpClient.new(configuration)
+    end
+
+    describe "#post" do
+      let(:data) { { message: "BEEF" } }
+
+      subject do
+        http_client.post "/events/", data
+      end
+
+      it "makes a post request" do
+        subject
+
+        expect(WebMock).to have_requested(:post, %r{/events/$}).with({
+          body: data,
+          headers: {
+            "Authorization" => 'Bearer TOKEN',
+            "Content-Type" => 'application/json',
+            "Content-Length" => data.to_json.bytesize,
+            "User-Agent" => HttpClient::USER_AGENT
+          }
+        })
+      end
+
+      it "doesn't post when state is failed" do
+        http_client.state.fail!
+        subject
+        expect(WebMock).to_not have_requested(:any, /.*/)
+      end
+
+      it "raises when server returns error" do
+        stub_request(:post, /.*/).and_return(status: 500)
+        expect { subject }.to raise_error(Error)
+      end
+    end
+
+    describe "#state" do
+      subject { http_client.state }
+
+      it "should try" do
+        expect(subject.should_try?).to be true
+      end
+
+      it "shouldn't try when state is failed" do
+        subject.fail!
+        expect(subject.should_try?).to be false
+      end
+    end
+
+  end
+end

data/spec/opbeat/injections/net_http_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+require 'open-uri'
+
+module Opbeat
+  RSpec.describe 'net/http integration', start_without_worker: true do
+
+    it "is installed" do
+      reg = Opbeat::Injections.installed['Net::HTTP']
+      expect(reg).to_not be_nil
+    end
+
+    it "traces http calls" do
+      Opbeat::Injections.installed['Net::HTTP'].install
+
+      WebMock.stub_request :get, 'http://example.com:80'
+
+      transaction = Opbeat.transaction 'Test'
+
+      Net::HTTP.start('example.com') do |http|
+        http.get '/'
+      end
+
+      expect(WebMock).to have_requested(:get, 'http://example.com')
+      expect(transaction.traces.length).to be 2
+
+      http_trace = transaction.traces.last
+      expect(http_trace.signature).to eq 'GET example.com'
+      expect(http_trace.extra).to eq({
+        scheme: 'http',
+        port: 80,
+        path: '/'
+      })
+    end
+
+  end
+end

data/spec/opbeat/injections/sequel_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'sequel'
+
+module Opbeat
+  RSpec.describe Injections::Sequel do
+
+    it "is installed" do
+      reg = Opbeat::Injections.installed['Sequel']
+      expect(reg).to_not be_nil
+    end
+
+    before do
+      @db = Sequel.sqlite # in-memory db
+
+      @db.create_table :tests do
+        primary_key :id
+        String :title
+      end
+
+      @db[:tests].count # warm it up
+    end
+
+    it "traces db calls", start_without_worker: true do
+      t = Opbeat.transaction 'Test' do
+        @db[:tests].count
+      end.done(true)
+
+      expect(t.traces.length).to be 2
+      expect(t.traces.last.signature).to eq 'SELECT FROM `tests`'
+    end
+
+  end
+end

data/spec/opbeat/injections/sinatra_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'sinatra'
+
+module Opbeat
+  RSpec.describe Injections::Sinatra do
+
+    it "is installed" do
+      reg = Opbeat::Injections.installed['Sinatra::Base']
+      expect(reg).to_not be_nil
+    end
+
+  end
+end

data/spec/opbeat/injections_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Injections do
+
+    class TestProbe
+      def initialize
+        @installations = 0
+      end
+      def install
+        @installations += 1
+      end
+      attr_reader :installations
+    end
+
+    let(:probe) { TestProbe.new }
+    subject { Opbeat::Injections }
+
+    it "installs right away if constant is defined" do
+      subject.register 'Opbeat', 'opbeat', probe
+      expect(probe.installations).to be 1
+    end
+
+    it "installs a require hook" do
+      subject.register 'SomeLib', 'opbeat', probe
+
+      expect(probe.installations).to be 0
+
+      class ::SomeLib; end
+      require 'opbeat'
+      expect(probe.installations).to be 1
+
+      require 'opbeat'
+      expect(probe.installations).to be 1
+    end
+
+    it "doesn't install something that never exists" do
+      subject.register 'SomethingElse', 'wut', probe
+      expect(probe.installations).to be 0
+    end
+
+    it "doesn't install when required but class is missing" do
+      subject.register 'SomethingElse', 'opbeat', probe
+      require 'opbeat'
+      expect(probe.installations).to be 0
+    end
+
+  end
+end

data/spec/opbeat/integration/delayed_job_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'delayed_job'
+rescue LoadError
+  puts "Skipping delayed_job specs"
+end
+# :nocov:
+
+if defined?(Delayed)
+  # so nasty
+  load File.join(
+    Gem::Specification.find_by_name("delayed_job").gem_dir,
+    "spec", "delayed", "backend", "test.rb"
+  )
+  Delayed::Worker.backend = Delayed::Backend::Test::Job
+
+  describe Delayed::Plugins::Opbeat, start_without_worker: true do
+    class MyJob
+      def blow_up e
+        raise e
+      end
+    end
+
+    it "reports exceptions to Opbeat" do
+      exception = Exception.new('BOOM')
+
+      MyJob.new.delay.blow_up exception
+
+      expect(Delayed::Worker.new.work_off).to eq [0, 1]
+      expect(Opbeat::Client.inst.queue.length).to be 1
+    end
+  end
+end

data/spec/opbeat/integration/json_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'json'
+
+RSpec.describe "JSON integration", start_without_worker: true do
+
+  if false # turned off for now
+    describe "#parse" do
+      it "adds a trace to current transaction" do
+        transaction = Opbeat.transaction 'JSON' do
+          JSON.parse('[{"something":1}]')
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq "JSON#parse"
+      end
+    end
+
+    describe "#parse" do
+      it "adds a trace to current transaction" do
+        transaction = Opbeat.transaction 'JSON' do
+          JSON.parse!('[{"something":1}]')
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq "JSON#parse!"
+      end
+    end
+
+    describe "#generate" do
+      it "adds a trace to current transaction" do
+        transaction = Opbeat.transaction 'JSON' do
+          JSON.generate([{something: 1}])
+        end.done(true)
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq "JSON#generate"
+      end
+    end
+  end
+
+end

data/spec/opbeat/integration/rails_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+require 'rails'
+require 'action_controller/railtie'
+require 'opbeat/integration/railtie'
+
+describe 'Rails integration' do
+  include Rack::Test::Methods
+
+  def boot
+    TinderButForHotDogs.initialize!
+    TinderButForHotDogs.routes.draw do
+      get 'error', to: 'users#error'
+      get 'json', to: 'users#other'
+      root to: 'users#index'
+    end
+  end
+
+  before :all do
+    class TinderButForHotDogs < ::Rails::Application
+      config.secret_key_base = '__secret_key_base'
+
+      config.logger = Logger.new(nil)
+      config.logger.level = Logger::DEBUG
+
+      config.eager_load = false
+
+      config.opbeat.app_id = 'APP_ID'
+      config.opbeat.organization_id = 'ORGANIZATION_ID'
+      config.opbeat.secret_token = 'SECRET_TOKEN'
+      config.opbeat.disable_worker = true
+    end
+
+    class UsersController < ActionController::Base
+      def index
+        render text: 'HOT DOGS!'
+      end
+
+      def other
+        json = Opbeat.trace('JSON.dump') { sleep 0.1; { result: :ok } }
+        render json: json
+      end
+
+      def error
+        raise Exception.new("NO KETCHUP!")
+      end
+    end
+
+    boot
+  end
+
+  after :all do
+    Object.send(:remove_const, :TinderButForHotDogs)
+    Object.send(:remove_const, :UsersController)
+    Rails.application = nil
+    Opbeat.stop!
+  end
+
+  def app
+    @app ||= Rails.application
+  end
+
+  before :each do
+    Opbeat::Client.inst.queue.clear
+    Opbeat::Client.inst.instance_variable_set :@pending_transactions, []
+  end
+
+  it "adds an exception handler and handles exceptions" do
+    get '/error'
+
+    expect(Opbeat::Client.inst.queue.length).to be 1
+  end
+
+  it "traces actions and enqueues transaction" do
+    get '/'
+
+    expect(Opbeat::Client.inst.pending_transactions.length).to be 1
+  end
+
+  it "logs when failing to report error" do
+    allow(Opbeat::Client.inst).to receive(:report).and_raise
+    allow(Rails.logger).to receive(:error)
+
+    get '/404'
+
+    expect(Rails.logger).to have_received(:error).with(/\*\* \[Opbeat\] Error capturing/)
+  end
+end

data/spec/opbeat/integration/redis_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+if defined?(Redis)
+  RSpec.describe "Redis integration", start_without_worker: true do
+
+    let(:redis) { Redis.new }
+
+    describe "#call" do
+      it "adds a trace to current transaction" do
+        transaction = Opbeat.transaction 'Redis' do
+          redis.lrange("some:where", 0, -1)
+        end
+
+        expect(transaction.traces.length).to be 2
+        expect(transaction.traces.last.signature).to eq 'lrange'
+      end
+    end
+
+  end
+end

data/spec/opbeat/integration/resque_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'resque'
+rescue LoadError
+  puts 'Skipping Resque specs'
+end
+# :nocov:
+
+if defined? Resque
+  RSpec.describe 'Resque integration', start_without_worker: true do
+
+    before do
+      # using fakeredis
+      Resque.redis = Redis.new
+
+      require 'resque/failure/multiple'
+      Resque::Failure::Multiple.classes = [Opbeat::Integration::Resque]
+      Resque::Failure.backend = Resque::Failure::Multiple
+    end
+
+    class MyWorker
+      @queue = :default
+
+      def self.perform txt
+        raise Exception.new txt
+      end
+    end
+
+    it "captures and reports exceptions" do
+      Resque.enqueue MyWorker, "BOOM"
+
+      worker = Resque::Worker.new(:default)
+      job = worker.reserve
+      worker.perform job
+
+      expect(Opbeat::Client.inst.queue.length).to be 1
+    end
+
+  end
+end

data/spec/opbeat/integration/sidekiq_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+# :nocov:
+begin
+  require 'sidekiq'
+rescue LoadError
+  puts 'Skipping Sidekiq specs'
+end
+# :nocov:
+
+if defined?(Sidekiq)
+  require 'sidekiq/testing'
+
+  Sidekiq::Testing.inline!
+  Sidekiq::Testing.server_middleware do |chain|
+    chain.add Opbeat::Integration::Sidekiq
+  end
+
+  RSpec.describe Opbeat::Integration::Sidekiq, start_without_worker: true do
+
+    class MyWorker
+      include Sidekiq::Worker
+
+      def perform ex
+        raise ex
+      end
+    end
+
+    it "captures and reports exceptions to opbeat" do
+      exception = Exception.new("BOOM")
+
+      expect do
+        MyWorker.perform_async exception
+      end.to raise_error(Exception)
+
+      expect(Opbeat::Client.inst.queue.length).to be 1
+    end
+
+  end
+end