opbeat 2.0.0 → 3.0.0

data/spec/opbeat/configuration_spec.rb

@@ -1,50 +1,46 @@
-require File::expand_path('../../spec_helper', __FILE__)
-require 'opbeat'
+require 'spec_helper'
 
-describe Opbeat::Configuration do
-  before do
-    # Make sure we reset the env in case something leaks in
-    ENV.delete('OPBEAT_ORGANIZATION_ID')
-    ENV.delete('OPBEAT_APP_ID')
-    ENV.delete('OPBEAT_SECRET_TOKEN')
-  end
-
-  shared_examples 'a complete configuration' do
-    it 'should have a server' do
-      expect(subject[:server]).to eq('http://opbeat.localdomain/opbeat')
-    end
+module Opbeat
+  RSpec.describe Configuration do
 
-    it 'should have an secret token' do
-      expect(subject[:secret_token]).to eq('67890')
+    it "has defaults" do
+      conf = Configuration.new
+      expect(conf.timeout).to be 100
     end
 
-    it 'should have an organization ID' do
-      expect(subject[:organization_id]).to eq('42')
+    it "can initialize with a hash" do
+      conf = Configuration.new timeout: 1000
+      expect(conf.timeout).to be 1000
     end
 
-    it 'should have an app ID' do
-      expect(subject[:app_id]).to eq('43')
+    it "yields itself to a given block" do
+      conf = Configuration.new do |c|
+        c.timeout = 1000
+      end
+      expect(conf.timeout).to be 1000
     end
-  end
 
-  context 'being initialized with options' do
-    before do
-      subject.server = 'http://opbeat.localdomain/opbeat'
-      subject.secret_token = '67890'
-      subject.organization_id = '42'
-      subject.app_id = '43'
+    describe "#validate" do
+      let(:auth_opts) { { app_id: 'x', organization_id: 'y', secret_token: 'z' } }
+      it "is true when all auth options are set" do
+        expect(Configuration.new(auth_opts).validate!).to be true
+      end
+      it "is true" do
+        expect(Configuration.new(auth_opts).validate!).to be true
+      end
+      it "needs an app_id" do
+        auth_opts.delete(:app_id)
+        expect(Configuration.new(auth_opts).validate!).to be false
+      end
+      it "needs an organization_id" do
+        auth_opts.delete(:organization_id)
+        expect(Configuration.new(auth_opts).validate!).to be false
+      end
+      it "needs a secret token" do
+        auth_opts.delete(:secret_token)
+        expect(Configuration.new(auth_opts).validate!).to be false
+      end
     end
-    it_should_behave_like 'a complete configuration'
-  end
 
-  context 'being initialized with an environment variable' do
-    subject do
-      ENV['OPBEAT_ORGANIZATION_ID'] = '42'
-      ENV['OPBEAT_APP_ID'] = '43'
-      ENV['OPBEAT_SECRET_TOKEN'] = '67890'
-      ENV['OPBEAT_SERVER'] = 'http://opbeat.localdomain/opbeat'
-      Opbeat::Configuration.new
-    end
-    it_should_behave_like 'a complete configuration'
   end
 end

data/spec/opbeat/data_builders/error_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Opbeat
+  module DataBuilders
+    RSpec.describe Error do
+
+      let(:config) { Configuration.new }
+
+      subject do
+        Error.new config
+      end
+
+      def real_exception
+        1 / 0
+      rescue => e
+        e
+      end
+
+      describe "#build" do
+        it "builds an error dict from an exception" do
+          error_message = ErrorMessage.from_exception config, real_exception
+          expect(subject.build error_message).to match({
+            message: String,
+            timestamp: Integer,
+            level: :error,
+            logger: 'root',
+            culprit: "opbeat/data_builders/error_spec.rb:14:in `/'",
+            machine: nil,
+            extra: nil,
+            param_message: nil,
+            exception: Hash,
+            stacktrace: Hash
+          })
+        end
+        it "converts to json just fine" do
+          error_message = ErrorMessage.from_exception config, real_exception
+          expect { JSON.dump subject.build(error_message) }.to_not raise_error
+        end
+      end
+
+    end
+  end
+end

data/spec/opbeat/data_builders/transactions_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module Opbeat
+  module DataBuilders
+    RSpec.describe Transactions, mock_time: true, start_without_worker: true do
+
+      describe "#build" do
+        subject do
+          transaction1 = Transaction.new(nil, 'endpoint', 'special.kind')
+          transaction2 = Transaction.new(nil, 'endpoint', 'special.kind')
+          transaction3 = Transaction.new(nil, 'endpoint', 'special.kind')
+          travel 100
+          transaction1.done 200
+          transaction2.done 200
+          transaction3.done 500
+
+          transaction4 = Opbeat.transaction('endpoint', 'special.kind') do
+            travel 100
+            Opbeat.trace 'things' do
+              travel 100
+            end
+            Opbeat.trace 'things' do
+              travel 100
+            end
+          end.done(500)
+
+          transactions = [transaction1, transaction2, transaction3, transaction4]
+
+          DataBuilders::Transactions.new(Configuration.new).build transactions
+        end
+
+        it "combines transactions by result" do
+          data = subject
+          expect(data[:transactions].length).to be 2
+          expect(data[:transactions].map { |t| t[:result] }).to eq [200, 500]
+          expect(data[:transactions].map { |t| t[:durations] }.flatten).to eq [100.0, 100.0, 100.0, 300.0]
+        end
+
+        it "combines traces" do
+          data = subject
+          expect(data[:traces].length). to be 2
+          expect(data[:traces].first[:durations].length).to be 4
+          expect(data[:traces].last[:durations].flatten).to eq [100.0, 300.0, 100.0, 300.0]
+          expect(data[:traces].last[:start_time].round).to eq 150
+        end
+      end
+
+    end
+
+  end
+end

data/spec/opbeat/error_message/exception_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe ErrorMessage::Exception do
+
+    class ::Thing
+      class Error < StandardError
+      end
+    end
+
+    describe ".from" do
+      it "initializes an object from an actual exception" do
+        exception = Thing::Error.new "BOOM"
+        obj = ErrorMessage::Exception.from(exception)
+        expect(obj.type).to eq "Thing::Error"
+        expect(obj.value).to eq "BOOM"
+        expect(obj.module).to eq "Thing"
+      end
+    end
+
+  end
+end

data/spec/opbeat/error_message/http_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe ErrorMessage::HTTP do
+
+    describe ".from_rack_env" do
+      let(:config) { Configuration.new }
+
+      it "initializes with a rack env" do
+        filter = Filter.new config
+
+        env = Rack::MockRequest.env_for '/nested/path?a=1&password=SECRET', {
+          'HTTP_COOKIE' => 'user_id=1',
+          'REMOTE_ADDR' => '1.2.3.4',
+          'HTTP_USER_AGENT'  => 'test-agent 1.2/3',
+          'HTTP_FOO' => 'bar'
+        }
+
+        http = ErrorMessage::HTTP.from_rack_env env, filter: filter
+
+        expect(http.url).to eq 'http://example.org/nested/path'
+        expect(http.method).to eq 'GET'
+        expect(http.query_string).to eq 'a=1&password=[FILTERED]'
+        expect(http.cookies).to eq('user_id=1')
+        expect(http.remote_host).to eq '1.2.3.4'
+        expect(http.http_host).to eq 'example.org:80'
+        expect(http.user_agent).to eq 'test-agent 1.2/3'
+
+        expect(http.headers).to eq({
+          'Cookie' => 'user_id=1',
+          'User-Agent' => 'test-agent 1.2/3',
+          'Foo' => 'bar'
+        })
+        expect(http.env).to eq(env.select do |k,v|
+          !k.match(/(^HTTP_|[a-z])/) # starting with HTTP_ or lower case
+        end)
+      end
+
+      it "adds form data" do
+        env = Rack::MockRequest.env_for '/', {
+          'REQUEST_METHOD' => 'POST',
+          input: 'thing=hotdog&accept=1'
+        }
+        http = ErrorMessage::HTTP.from_rack_env env
+
+        expect(http.data).to eq({
+          'thing' => 'hotdog',
+          'accept' => '1'
+        })
+      end
+
+      it "adds body" do
+        env = Rack::MockRequest.env_for '/', {
+          'REQUEST_METHOD' => 'POST',
+          'CONTENT_TYPE' => 'application/json',
+          input: { thing: 'hotdog' }.to_json
+        }
+        http = ErrorMessage::HTTP.from_rack_env env
+
+        expect(http.data).to eq('{"thing":"hotdog"}')
+      end
+    end
+
+  end
+end

data/spec/opbeat/error_message/stacktrace_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe ErrorMessage::Stacktrace do
+
+    def real_exception
+      1 / 0
+    rescue => e
+      e
+    end
+
+    let(:config) { Configuration.new }
+    let(:exception) { real_exception }
+
+    describe ".from" do
+      it "initializes from an exception" do
+        stacktrace = ErrorMessage::Stacktrace.from config, exception
+        expect(stacktrace.frames).to_not be_empty
+
+        # so meta
+        last_frame = stacktrace.frames.first
+        expect(last_frame.filename).to eq "opbeat/error_message/stacktrace_spec.rb"
+        expect(last_frame.lineno).to be 7
+        expect(last_frame.abs_path).to_not be_nil
+        expect(last_frame.function).to eq "/"
+        expect(last_frame.vars).to be_nil
+
+        expect(last_frame.pre_context.last).to match(/def real_exception/)
+        expect(last_frame.context_line).to match(/1 \/ 0/)
+        expect(last_frame.post_context.first).to match(/rescue/)
+      end
+
+      context "when context lines are off" do
+        let(:config) { Configuration.new context_lines: nil }
+        it "initializes too" do
+          stacktrace = ErrorMessage::Stacktrace.from config, exception
+          expect(stacktrace.frames).to_not be_empty
+
+          last_frame = stacktrace.frames.last
+          expect(last_frame.pre_context).to be_nil
+          expect(last_frame.context_line).to be_nil
+          expect(last_frame.post_context).to be_nil
+        end
+      end
+    end
+
+    describe "#to_h" do
+      it "is a hash" do
+        hsh = ErrorMessage::Stacktrace.from(config, exception).to_h
+        expect(hsh).to be_a Hash
+        expect(hsh.keys).to eq [:frames]
+      end
+    end
+
+  end
+end

data/spec/opbeat/error_message/user_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe ErrorMessage::User do
+
+    let(:config) { Configuration.new }
+
+    class Controller
+      def current_user
+        Struct.new(:id, :email, :username).new(1, 'john@example.com', 'leroy')
+      end
+    end
+
+    describe ".from_rack_env" do
+      it "initializes from rack env" do
+        env = Rack::MockRequest.env_for '/', {
+          'action_controller.instance' => Controller.new
+        }
+        user = ErrorMessage::User.from_rack_env config, env
+
+        expect(user.id).to be 1
+        expect(user.email).to eq 'john@example.com'
+        expect(user.username).to eq 'leroy'
+      end
+    end
+
+  end
+end

data/spec/opbeat/error_message_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe ErrorMessage do
+
+    let(:config) { Configuration.new }
+
+    def real_exception
+      1 / 0
+    rescue => e
+      e
+    end
+
+    describe "#initialize" do
+      it "sets attrs by hash" do
+        error = ErrorMessage.new config, 'Error', level: :warn
+        expect(error.level).to eq :warn
+      end
+      it "yields itself" do
+        error = ErrorMessage.new(config, 'Error') { |m| m.level = :warn }
+        expect(error.level).to eq :warn
+      end
+    end
+
+    describe ".from_exception" do
+      it "initializes from an exception" do
+        error = ErrorMessage.from_exception config, real_exception
+        expect(error.message).to eq 'ZeroDivisionError: divided by 0'
+        expect(error.level).to eq :error
+
+        expect(error.exception.type).to eq 'ZeroDivisionError'
+        expect(error.exception.value).to eq 'divided by 0'
+        expect(error.exception.module).to eq ''
+
+        expect(error.stacktrace.frames.length).to_not be 0
+        expect(error.stacktrace.frames.map(&:class).uniq)
+          .to eq [ErrorMessage::Stacktrace::Frame]
+        expect(error.culprit).to eq "opbeat/error_message_spec.rb:9:in `/'"
+      end
+
+      it "skips excluded exceptions" do
+        class ::SleepDeprivationError < StandardError; end
+        exception = SleepDeprivationError.new('so tired')
+        config.excluded_exceptions += %w{SleepDeprivationError}
+
+        error = ErrorMessage.from_exception config, exception
+        expect(error).to be_nil
+      end
+
+      context "with a rack env" do
+        it "adds rack env to message" do
+          env = Rack::MockRequest.env_for '/'
+          error = ErrorMessage.from_exception config, real_exception, rack_env: env
+
+          expect(error.http).to be_a(ErrorMessage::HTTP)
+          expect(error.http.url).to eq 'http://example.org/'
+        end
+
+        class DummyController
+          def current_user
+            Struct.new(:id, :email, :username).new(1, 'john@example.com', 'leroy')
+          end
+        end
+
+        it "adds user from controller" do
+          env = Rack::MockRequest.env_for '/', {
+            'action_controller.instance' => DummyController.new
+          }
+          error = ErrorMessage.from_exception config, real_exception, rack_env: env
+
+          expect(error.user).to be_a(ErrorMessage::User)
+          expect(error.user.id).to be 1
+        end
+      end
+    end
+
+  end
+end

data/spec/opbeat/filter_spec.rb

@@ -1,101 +1,23 @@
-require File::expand_path('../../spec_helper', __FILE__)
-require 'opbeat/filter'
-
-describe Opbeat::Filter do
-  it 'should filter http data by default' do
-    data = {
-      'http' => {
-        'data' => {
-          'foo' => 'bar',
-          'password' => 'hello',
-          'the_secret' => 'hello',
-          'a_password_here' => 'hello',
-          'mypasswd' => 'hello'
-        }
-      }
-    }
-
-    filter = Opbeat::Filter.new
-    result = filter.process_event_hash(data)
-
-    vars = result["http"]["data"]
-    expect(vars["foo"]).to eq("bar")
-    expect(vars["password"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["the_secret"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["a_password_here"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["mypasswd"]).to eq(Opbeat::Filter::MASK)
-  end
-
-  it 'should filter http query_string by default' do
-    data = {
-      'http' => {
-        'query_string' => 'foo=bar&password=secret'
-      }
-    }
-
-    filter = Opbeat::Filter.new
-    result = filter.process_event_hash(data)
-
-    expect(result["http"]["query_string"]).to eq('foo=bar&password=' + Opbeat::Filter::MASK)
-  end
-
-  it 'should filter http cookies by default' do
-    data = {
-      'http' => {
-        'cookies' => 'foo=bar;password=secret'
-      }
-    }
-
-    filter = Opbeat::Filter.new
-    result = filter.process_event_hash(data)
-
-    expect(result["http"]["cookies"]).to eq('foo=bar;password=' + Opbeat::Filter::MASK)
-  end
-
-  it 'should not filter env, extra or headers' do
-    data = {
-      'http' => {
-        'env' => { 'password' => 'hello' },
-        'extra' => { 'password' => 'hello' },
-        'headers' => { 'password' => 'hello' }
-      }
-    }
-
-    filter = Opbeat::Filter.new
-    result = filter.process_event_hash(data)
-
-    expect(result).to eq(data)
-  end
-
-  it 'should be configurable' do
-    data = {
-      'http' => {
-        'data' => {
-          'foo' => 'secret',
-          'bar' => 'secret',
-          '-baz-' => 'secret',
-          'password' => 'public',
-          'the_secret' => 'public',
-          'a_password_here' => 'public',
-          'mypasswd' => 'public'
-        },
-        'query_string' => 'foo=secret&password=public',
-        'cookies' => 'foo=secret;password=public'
-      }
-    }
-
-    filter = Opbeat::Filter.new [:foo, 'bar', /baz/]
-    result = filter.process_event_hash(data)
-
-    vars = result["http"]["data"]
-    expect(vars["foo"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["bar"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["-baz-"]).to eq(Opbeat::Filter::MASK)
-    expect(vars["password"]).to eq("public")
-    expect(vars["the_secret"]).to eq("public")
-    expect(vars["a_password_here"]).to eq("public")
-    expect(vars["mypasswd"]).to eq("public")
-    expect(result["http"]["query_string"]).to eq('foo=' + Opbeat::Filter::MASK + '&password=public')
-    expect(result["http"]["cookies"]).to eq('foo=' + Opbeat::Filter::MASK + ';password=public')
+require 'spec_helper'
+
+module Opbeat
+  RSpec.describe Filter do
+    let(:config) { Configuration.new filter_parameters: [/password/, 'passwd'] }
+
+    subject do
+      Filter.new config
+    end
+
+    describe "#apply" do
+      it "filters a string" do
+        filtered = subject.apply "password=SECRET&foo=bar"
+        expect(filtered).to eq 'password=[FILTERED]&foo=bar'
+      end
+
+      it "filters a hash" do
+        filtered = subject.apply({ passwd: 'SECRET' })
+        expect(filtered).to eq({ passwd: '[FILTERED]' })
+      end
+    end
   end
 end