opbeat 2.0.0 → 3.0.0

data/spec/opbeat/integration/sinatra_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'sinatra'
+
+module Opbeat
+  RSpec.describe "sinatra integration" do
+    include Rack::Test::Methods
+
+    def config
+      @config ||= Opbeat::Configuration.new do |c|
+        c.app_id = 'X'
+        c.organization_id = 'Y'
+        c.secret_token = 'Z'
+        c.disable_worker = true
+      end
+    end
+
+    around do |example|
+      Opbeat.start! config
+      example.call
+      Opbeat.stop!
+    end
+
+    class TestApp < ::Sinatra::Base
+      disable :show_exceptions
+      use Opbeat::Middleware
+
+      get '/' do
+        erb "I am an inline template!"
+      end
+
+      template :tmpl do
+        "I am a template!"
+      end
+
+      get '/tmpl' do
+        erb :tmpl
+      end
+    end
+
+    def app
+      TestApp
+    end
+
+    it "wraps routes in transactions" do
+      get '/'
+
+      transaction = Opbeat::Client.inst.pending_transactions.last
+      expect(transaction.endpoint).to eq 'GET /'
+    end
+
+    it "traces templates" do
+      get '/tmpl'
+
+      transaction = Opbeat::Client.inst.pending_transactions.last
+      expect(transaction.traces.last.signature).to eq 'tmpl'
+    end
+
+    it "traces inline templates" do
+      get '/'
+
+      transaction = Opbeat::Client.inst.pending_transactions.last
+      expect(transaction.traces.last.signature).to eq 'Inline erb'
+    end
+
+  end
+end

data/spec/opbeat/line_cache_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe LineCache do
+
+    let(:path) { "some/file.rb" }
+    let(:lines) { %w{these are the lines} }
+
+    describe ".all" do
+      it "returns the lines of the file at path" do
+        allow(File).to receive(:readlines) { lines }
+        expect(LineCache.all path).to eq lines
+      end
+      it "rescues any exception" do
+        allow(LineCache::CACHE).to receive(:[]) { nil }
+        allow(File).to receive(:readlines).and_raise "BOOM"
+        expect(LineCache.all path).to eq []
+      end
+      it "caches results" do
+        allow(File).to receive(:readlines) { lines }.once
+        LineCache.all path
+        LineCache.all path
+      end
+    end
+
+    describe ".find" do
+      it "returns one line of the file at path" do
+        allow(File).to receive(:readlines) { lines }.once
+        allow(LineCache::CACHE).to receive(:[]) { nil }
+        expect(LineCache.find path, 2).to eq "are"
+      end
+      it "is nil when less than 1" do
+        expect(LineCache.find path, 0).to be_nil
+      end
+    end
+
+  end
+end

data/spec/opbeat/logging_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'opbeat'
+
+module Opbeat
+  describe Logging do
+    class FakeLogger
+      def method_missing name, *args, &block
+        @calls ||= []
+        @calls << [name, *args]
+      end
+      attr_reader :calls
+    end
+
+    let(:logger) { FakeLogger.new }
+    let(:config) { Struct.new(:logger).new(logger) }
+
+    before :each do
+      extend Logging
+    end
+
+    %w{fatal error info debug warn}.map(&:to_sym).each do |level|
+      it "does #{level} with args" do
+        self.send level, "msg"
+        expect(logger.calls.last).to eq [level, "** [Opbeat] msg"]
+      end
+      it "does #{level} with block" do
+        blck = lambda { "msg" }
+        self.send level, &blck
+        expect(logger.calls.last).to eq [level, "** [Opbeat] msg"]
+      end
+    end
+
+    context 'without a backend logger' do
+      before do
+        config.logger = nil
+      end
+
+      it 'should not error' do
+        fatal 'fatalmsg'
+        error 'errormsg'
+        warn 'warnmsg'
+        info 'infomsg'
+        debug 'debugmsg'
+      end
+    end
+  end
+end

data/spec/opbeat/middleware_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'opbeat'
+
+module Opbeat
+  describe Middleware, start_without_worker: true do
+
+    it "surrounds the request in a transaction" do
+      app = Middleware.new(lambda do |env|
+        [200, {}, ['']]
+      end)
+      status, _, body = app.call(Rack::MockRequest.env_for '/')
+      body.close
+
+      expect(status).to eq 200
+      expect(Opbeat::Client.inst.pending_transactions.length).to be 1
+      expect(Opbeat::Client.inst.current_transaction).to be_nil
+    end
+
+    it "submits on exceptions" do
+      app = Middleware.new(lambda do |env|
+        raise Exception, "BOOM"
+      end)
+
+      expect { app.call(Rack::MockRequest.env_for '/') }.to raise_error(Exception)
+      expect(Opbeat::Client.inst.queue.length).to be 1
+      expect(Opbeat::Client.inst.current_transaction).to be_nil
+
+      expect(Opbeat::Client.inst.queue.length).to be 1
+    end
+
+  end
+end

data/spec/opbeat/normalizers/action_controller_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Normalizers::ActionController do
+
+    let(:config) { Configuration.new }
+    let(:normalizers) { Normalizers.build config }
+
+    describe Normalizers::ActionController::ProcessAction do
+      subject do
+        normalizers.normalizer_for('process_action.action_controller')
+      end
+
+      it "registers" do
+        expect(subject).to be_a Normalizers::ActionController::ProcessAction
+      end
+
+      describe "#normalize" do
+        it "normalizes input and updates transaction" do
+          transaction = Struct.new(:endpoint).new(nil)
+
+          result = subject.normalize(transaction, 'process_action.action_controller', {
+            controller: 'SomeController', action: 'index'
+          })
+
+          expect(transaction.endpoint).to eq 'SomeController#index'
+          expect(result).to match ['SomeController#index', 'app.controller.action', nil]
+        end
+      end
+    end
+  end
+end

data/spec/opbeat/normalizers/action_view_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Normalizers::ActionView do
+
+    let(:config) { Configuration.new view_paths: ['/var/www/app/views'] }
+    let(:normalizers) { Normalizers.build config }
+
+    shared_examples_for :a_render_normalizer do |key|
+      describe "#normalize" do
+        it "normalizes an unknown template" do
+          expect(normalize key, {}).to eq ['Unknown template', described_class.const_get(:KIND), nil]
+        end
+
+        it "returns a local template" do
+          path = 'somewhere/local.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'somewhere/local.html.erb'
+        end
+
+        it "looks up a template in config.view_paths" do
+          path = '/var/www/app/views/users/index.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'users/index.html.erb'
+        end
+
+        it "truncates gem path" do
+          path = Gem.path[0] + '/some/template.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq '$GEM_PATH/some/template.html.erb'
+        end
+
+        it "returns absolute if not found in known dirs" do
+          path = '/somewhere/else.html.erb'
+          expect(normalize(key, identifier: path)[0]).to eq 'Absolute path'
+        end
+
+        def normalize key, payload
+          subject.normalize nil, key, payload
+        end
+      end
+    end
+
+    describe Normalizers::ActionView::RenderTemplate do
+      subject do
+        normalizers.normalizer_for 'render_template.action_view'
+      end
+
+      it "registers" do
+        expect(subject).to be_a Normalizers::ActionView::RenderTemplate
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+
+    describe Normalizers::ActionView::RenderPartial do
+      subject do
+        normalizers.normalizer_for 'render_partial.action_view'
+      end
+
+      it "registers" do
+        expect(subject).to be_a Normalizers::ActionView::RenderPartial
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+
+    describe Normalizers::ActionView::RenderCollection do
+      subject do
+        normalizers.normalizer_for 'render_collection.action_view'
+      end
+
+      it "registers" do
+        expect(subject).to be_a Normalizers::ActionView::RenderCollection
+      end
+
+      it_should_behave_like :a_render_normalizer
+    end
+  end
+end

data/spec/opbeat/normalizers/active_record_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Normalizers::ActionView do
+
+    let(:config) { Configuration.new view_paths: ['/var/www/app/views'] }
+    let(:normalizers) { Normalizers.build config }
+
+    describe Normalizers::ActiveRecord::SQL do
+      subject { normalizers.normalizer_for 'sql.active_record' }
+
+      it "registers" do
+        expect(subject).to be_a Normalizers::ActiveRecord::SQL
+      end
+
+      describe "#normalize" do
+        it "skips SCHEMA queries" do
+          expect(normalize(name: 'SCHEMA')).to be :skip
+        end
+
+        it "skips CACHE queries" do
+          expect(normalize(name: 'CACHE', sql: 'select * from tables')).to be :skip
+        end
+
+        it "normalizes SELECT queries" do
+          sql = 'SELECT  "hotdogs".* FROM "hotdogs" WHERE "hotdogs"."topping" = $1 LIMIT 1'
+          signature, kind, extra = normalize(name: 'Hotdogs load', sql: sql)
+          expect(signature).to eq 'SELECT FROM "hotdogs"'
+          expect(kind).to eq 'db.unknown.sql'
+          expect(extra).to eq sql: sql
+        end
+
+        it "normalizes INSERT queries" do
+          sig, _, _ = normalize(name: 'Hotdogs create',
+                                sql: 'insert into "hotdogs" (kind, topping) values ($1, $2)')
+          expect(sig).to eq 'INSERT INTO "hotdogs"'
+        end
+
+        it "normalizes UPDATE queries" do
+          sig, _, _ = normalize(name: 'Hotdogs update',
+                                sql: 'update "hotdogs" (topping) values ($1) where id=1')
+          expect(sig).to eq 'UPDATE "hotdogs"'
+        end
+
+        it "normalizes DELETE queries" do
+          sig, _, _ = normalize(name: 'Hotdogs delete',
+                                sql: 'delete from "hotdogs" where id=1')
+          expect(sig).to eq 'DELETE FROM "hotdogs"'
+        end
+
+        context "inside AR" do
+          before do
+            module ::ActiveRecord; class Base; end; end unless defined? ActiveRecord
+            allow(::ActiveRecord::Base).to receive(:connection) { double(adapter_name: 'MySQL') }
+          end
+          it "knows the ar adapter" do
+            _, kind, _ = normalize(name: 'Hotdogs load',
+                                   sql: 'select * from "hotdogs"')
+            expect(kind).to eq 'db.mysql.sql'
+          end
+        end
+
+        def normalize payload
+          subject.normalize nil, 'sql.active_record', payload
+        end
+      end
+    end
+
+  end
+end

data/spec/opbeat/normalizers_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Normalizers do
+
+    let(:config) { Configuration.new }
+
+    describe Normalizers::Default do
+      it "skips" do
+        normalizer = Normalizers::Default.new config
+        expect(normalizer.normalize 1, 2, 3).to eq :skip
+      end
+    end
+
+  end
+end

data/spec/opbeat/sql_summarizer_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe SqlSummarizer do
+  end
+end

data/spec/opbeat/subscriber_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Subscriber do
+
+    let(:config) { Configuration.new }
+    let(:client) { Client.new config }
+
+    subject do
+      Subscriber.new config, client
+    end
+
+    describe "#register!" do
+      it "subscribes to ActiveSupport::Notifications" do
+        expect(ActiveSupport::Notifications).to receive(:subscribe)
+        subject.register!
+      end
+      it "unregisters first if already registered" do
+        subject.register!
+        expect(subject).to receive(:unregister!)
+        expect(ActiveSupport::Notifications).to receive(:subscribe)
+        subject.register!
+      end
+    end
+
+    describe "#unregister" do
+      it "unsubscribes to AS::Notifications" do
+        expect(ActiveSupport::Notifications).to receive(:unsubscribe)
+        subject.register!
+        subject.unregister!
+      end
+    end
+
+    describe "ActiveSupport::Notifications API", start_without_worker: true do
+      let(:message_args) do
+        [
+          'process_action.action_controller',
+          nil,
+          { controller: 'Controller', action: 'index' }
+        ]
+      end
+      describe "#start" do
+        it "adds a new notification to current transaction" do
+          transaction = Opbeat.transaction 'Test'
+
+          expect do
+            subject.start(*message_args)
+          end.to change(transaction.notifications, :length).by 1
+
+          transaction.release
+        end
+      end
+
+      describe "#finish" do
+        it "adds a trace to current transaction" do
+          transaction = Opbeat.transaction 'Test'
+
+          expect do
+            subject.start(*message_args)
+            subject.finish(*message_args)
+          end.to change(transaction.traces, :length).by 1
+
+          transaction.release
+        end
+        it "adds a stack of parents", mock_time: true do
+          transaction = Opbeat.transaction 'Rack' do
+            subject.start(*message_args)
+            travel 100
+            Opbeat.trace('thing-1') do
+              travel 100
+            end
+            travel 100
+            subject.finish(*message_args)
+          end.done(200)
+
+          expect(transaction.traces.length).to eq 3
+          expect(transaction.traces.last.parents.map(&:signature)).to eq ['transaction', 'Controller#index']
+        end
+      end
+    end
+
+  end
+end