appsignal 1.0.7 → 1.1.0.beta.1

data/spec/lib/appsignal/hooks_spec.rb

@@ -74,3 +74,118 @@ describe Appsignal::Hooks do
     Appsignal::Hooks.hooks[:mock_error_hook].installed?.should be_false
   end
 end
+
+describe Appsignal::Hooks::Helpers do
+  class ClassWithHelpers
+    include Appsignal::Hooks::Helpers
+  end
+  let(:with_helpers) { ClassWithHelpers.new }
+
+  describe "#truncate" do
+    let(:very_long_text) do
+      "a" * 400
+    end
+
+    it "should truncate the text to 200 chars max" do
+      with_helpers.truncate(very_long_text).should == "#{'a' * 197}..."
+    end
+  end
+
+  describe "#string_or_inspect" do
+    context "when string" do
+      it "should return the string" do
+        with_helpers.string_or_inspect('foo').should == 'foo'
+      end
+    end
+
+    context "when integer" do
+      it "should return the string" do
+        with_helpers.string_or_inspect(1).should == '1'
+      end
+    end
+
+    context "when object" do
+      let(:object) { Object.new }
+
+      it "should return the string" do
+        with_helpers.string_or_inspect(object).should == object.inspect
+      end
+    end
+  end
+
+  describe "#extract_value" do
+    context "for a hash" do
+      let(:hash) { {:key => 'value'} }
+
+      context "when the key exists" do
+        subject { with_helpers.extract_value(hash, :key) }
+
+        it { should == 'value' }
+      end
+
+      context "when the key does not exist" do
+        subject { with_helpers.extract_value(hash, :nonexistent_key) }
+
+        it { should be_nil }
+
+        context "with a default value" do
+          subject { with_helpers.extract_value(hash, :nonexistent_key, 1) }
+
+          it { should == 1 }
+        end
+      end
+    end
+
+    context "for an object" do
+      let(:object) { double(:existing_method => 'value') }
+
+      context "when the method exists" do
+        subject { with_helpers.extract_value(object, :existing_method) }
+
+        it { should == 'value' }
+      end
+
+      context "when the method does not exist" do
+        subject { with_helpers.extract_value(object, :nonexistent_method) }
+
+        it { should be_nil }
+
+        context "and there is a default value" do
+          subject { with_helpers.extract_value(object, :nonexistent_method, 1) }
+
+          it { should == 1 }
+        end
+      end
+
+    end
+
+    context "when we need to call to_s on the value" do
+      let(:object) { double(:existing_method => 1) }
+
+      subject { with_helpers.extract_value(object, :existing_method, nil, true) }
+
+      it { should == '1' }
+    end
+  end
+
+  describe "#format_args" do
+    let(:object) { Object.new }
+    let(:args) do
+      [
+        'Model',
+        1,
+        object,
+        'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
+      ]
+    end
+
+    it "should format the arguments" do
+      with_helpers.format_args(args).should == [
+        'Model',
+        '1',
+        object.inspect,
+        'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ...'
+      ]
+    end
+  end
+end

data/spec/lib/appsignal/integrations/grape_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+if grape_present?
+  require 'appsignal/integrations/grape'
+
+  describe Appsignal::Grape::Middleware do
+
+    before :all do
+      start_agent
+    end
+
+    let(:app)          { double(:call => true) }
+    let(:api_endpoint) { double(:options => options) }
+    let(:options)      { {
+      :for    => 'Api::PostPut',
+      :method => ['POST'],
+      :path   => ['ping']
+    }}
+    let(:env) do
+      http_request_env_with_data('api.endpoint' => api_endpoint)
+    end
+    let(:middleware) { Appsignal::Grape::Middleware.new(app) }
+
+    describe "#call" do
+      context "when appsignal is active" do
+        before { Appsignal.stub(:active? => true) }
+
+        it "should call with monitoring" do
+          expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
+        end
+      end
+
+      context "when appsignal is not active" do
+        before { Appsignal.stub(:active? => false) }
+
+        it "should not call with monitoring" do
+          expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
+        end
+
+        it "should call the app" do
+          expect( app ).to receive(:call).with(env)
+        end
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe "#call_with_appsignal_monitoring" do
+      before { SecureRandom.stub(:uuid => '1') }
+
+      it "should create a transaction" do
+        Appsignal::Transaction.should_receive(:create).with(
+          '1',
+          Appsignal::Transaction::HTTP_REQUEST,
+          kind_of(::Rack::Request)
+        ).and_return(
+          double(
+            :set_action                         => nil,
+            :set_http_or_background_queue_start => nil,
+            :set_metadata                       => nil
+          )
+        )
+      end
+
+      it "should call the app" do
+        app.should_receive(:call).with(env)
+      end
+
+      context "with an error" do
+        let(:error) { VerySpecificError.new }
+        let(:app) do
+          double.tap do |d|
+            d.stub(:call).and_raise(error)
+          end
+        end
+
+        it "should set the error" do
+          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+        end
+      end
+
+      it "should set metadata" do
+        Appsignal::Transaction.any_instance.should_receive(:set_metadata).twice
+      end
+
+      it "should set the action and queue start" do
+        Appsignal::Transaction.any_instance.should_receive(:set_action).with('POST::Api::PostPut#ping')
+        Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
+      end
+
+      after { middleware.call(env) rescue VerySpecificError }
+    end
+  end
+end

data/spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb

@@ -11,15 +11,13 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
     describe "#started" do
       let(:event) do
         double(
-          :request_id   => 1,
-          :command_name => 'find',
-          :command      => {'foo' => 'bar'}
+          :request_id => 1,
+          :command    => {'foo' => 'bar'}
         )
       end
 
       it "should sanitize command" do
-        Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
-          .should receive(:format).with('find', {'foo' => 'bar'})
+        Appsignal::Utils.should receive(:sanitize).with({'foo' => 'bar'} )
 
         subscriber.started(event)
       end
@@ -83,9 +81,8 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
         Appsignal::Extension.should receive(:finish_event).with(
           transaction.transaction_index,
           'query.mongodb',
-          'find | test | SUCCEEDED',
-          "{\"foo\":\"?\"}",
-          0
+          'find',
+          "test | SUCCEEDED | {\"foo\"=>\"?\"}"
         )
 
         subscriber.finish('SUCCEEDED', event)

data/spec/lib/appsignal/integrations/resque_spec.rb

@@ -31,7 +31,6 @@ if resque_present?
         before do
           transaction.stub(:complete => true)
           Appsignal::Transaction.stub(:current => transaction)
-          Appsignal.should_receive(:stop)
         end
 
         context "without exception" do

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -87,7 +87,6 @@ describe Appsignal::JSExceptionTransaction do
   describe "#complete!" do
     it "should call all required methods" do
       expect( Appsignal::Extension ).to receive(:finish_transaction).with(kind_of(Integer))
-      expect( Appsignal::Extension ).to receive(:complete_transaction).with(kind_of(Integer))
       transaction.complete!
     end
   end

data/spec/lib/appsignal/subscriber_spec.rb

@@ -98,10 +98,10 @@ describe Appsignal::Subscriber do
 
       it "should call native start and finish event for every event" do
         Appsignal::Extension.should_receive(:start_event).exactly(4).times
-        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'one', '', '', 0).once
-        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'two', '', '', 0).once
-        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'two.three', '', '', 0).once
-        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'one.three', '', '', 0).once
+        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'one', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'two', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'two.three', '', '').once
+        Appsignal::Extension.should_receive(:finish_event).with(kind_of(Integer), 'one.three', '', '').once
 
         ActiveSupport::Notifications.instrument('one') do
           ActiveSupport::Notifications.instrument('two') do
@@ -119,8 +119,7 @@ describe Appsignal::Subscriber do
           kind_of(Integer),
           'request.net_http',
           'GET http://www.google.com',
-          '',
-          0
+          ''
         ).once
 
         ActiveSupport::Notifications.instrument(
@@ -131,23 +130,6 @@ describe Appsignal::Subscriber do
         )
       end
 
-      it "should call finish with title, body and body format if there is a formatter that returns it" do
-        Appsignal::Extension.should_receive(:start_event).once
-        Appsignal::Extension.should_receive(:finish_event).with(
-          kind_of(Integer),
-          'sql.active_record',
-          'Something load',
-          'SELECT * FROM something',
-          1
-        ).once
-
-        ActiveSupport::Notifications.instrument(
-          'sql.active_record',
-          :name => 'Something load',
-          :sql  => 'SELECT * FROM something'
-        )
-      end
-
       context "when paused" do
         before { transaction.pause! }
 

data/spec/lib/appsignal/transaction_spec.rb

@@ -331,11 +331,6 @@ describe Appsignal::Transaction do
           'params',
           '{"controller":"blog_posts","action":"show","id":"1"}'
         ).once
-        Appsignal::Extension.should_receive(:set_transaction_sample_data).with(
-          kind_of(Integer),
-          'metadata',
-          '{"key":"value"}'
-        ).once
         Appsignal::Extension.should_receive(:set_transaction_sample_data).with(
           kind_of(Integer),
           'tags',
@@ -621,22 +616,6 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe "#metadata" do
-      subject { transaction.send(:metadata) }
-
-      context "when env is nil" do
-        before { transaction.request.stub(:env => nil) }
-
-        it { should be_nil }
-      end
-
-      context "when env is present" do
-        let(:env) { {:metadata => {:key => 'value'}} }
-
-        it { should == env[:metadata] }
-      end
-    end
-
     describe '#sanitized_tags' do
       before do
         transaction.set_tags(

data/spec/lib/appsignal/utils_spec.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 describe Appsignal::Utils do
@@ -20,22 +18,13 @@ describe Appsignal::Utils do
       end
     end
 
-    context "when params is an array of strings" do
+    context "when params is an array of strings " do
       let(:params) { ['foo', 'bar'] }
 
       it "should sanitize all hash values with a single questionmark" do
         expect( Appsignal::Utils.sanitize(params) ).to eq(['?'])
       end
     end
-
-    context "when params is a mixed array" do
-      let(:params) { [nil, 'foo', 'bar'] }
-
-      it "should sanitize all hash values with a single questionmark" do
-        expect( Appsignal::Utils.sanitize(params) ).to eq(['?'])
-      end
-    end
-
     context "when params is a string" do
       let(:params) { 'bar'}
 
@@ -44,60 +33,4 @@ describe Appsignal::Utils do
       end
     end
   end
-
-  describe ".sanitize_key" do
-    it "should not sanitize key when no key_sanitizer is given" do
-      expect( Appsignal::Utils.sanitize_key('foo', nil) ).to eql('foo')
-    end
-
-    context "with mongodb sanitizer" do
-      it "should not sanitize key when no dots are in the key" do
-        expect( Appsignal::Utils.sanitize_key('foo', :mongodb) ).to eql('foo')
-      end
-
-      it "should sanitize key when dots are in the key" do
-        expect( Appsignal::Utils.sanitize_key('foo.bar', :mongodb) ).to eql('foo.?')
-      end
-
-      it "should sanitize a symbol" do
-        expect( Appsignal::Utils.sanitize_key(:ismaster, :mongodb) ).to eql('ismaster')
-      end
-    end
-  end
-
-  describe ".json_generate" do
-    subject { Appsignal::Utils.json_generate(body) }
-
-    context "with a valid body" do
-      let(:body) { {'the' => 'payload'} }
-
-      it { should == "{\"the\":\"payload\"}" }
-    end
-
-    context "with a body that contains strings with invalid utf-8 content" do
-      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack('c*') }
-      let(:body) { {
-        'field_one' => [0x61, 0x61].pack('c*'),
-        'field_two' => string_with_invalid_utf8,
-        'field_three' => [
-          'one', string_with_invalid_utf8
-        ],
-        'field_four' => {
-          'one' => string_with_invalid_utf8
-        }
-      } }
-
-      it { should == "{\"field_one\":\"aa\",\"field_two\":\"aa�\",\"field_three\":[\"one\",\"aa�\"],\"field_four\":{\"one\":\"aa�\"}}" }
-    end
-  end
-
-  describe ".encode_utf8" do
-    subject { Appsignal::Utils.encode_utf8(value) }
-
-    context "value with invalid utf-8 content" do
-      let(:value) { [0x61, 0x61, 0x85].pack('c*') }
-
-      it { should == "aa�" }
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,8 @@ require 'webmock/rspec'
 
 puts "Runnings specs in #{RUBY_VERSION} on #{RUBY_PLATFORM}"
 
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support/stubs'))
+
 begin
   require 'rails'
   Dir[File.expand_path(File.join(File.dirname(__FILE__), 'support/rails','*.rb'))].each {|f| require f}
@@ -21,6 +23,13 @@ def rails_present?
   RAILS_PRESENT
 end
 
+def active_job_present?
+  require 'active_job'
+  true
+rescue LoadError
+  false
+end
+
 def active_record_present?
   require 'active_record'
   true
@@ -67,6 +76,13 @@ rescue LoadError
   false
 end
 
+def grape_present?
+  require 'grape'
+  true
+rescue LoadError
+  false
+end
+
 require 'appsignal'
 
 Dir[File.expand_path(File.join(File.dirname(__FILE__), 'support/helpers','*.rb'))].each {|f| require f}