appsignal 1.2.5 → 1.3.0.beta.1

data/spec/lib/appsignal/hooks/redis_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Appsignal::Hooks::RedisHook do
   before :all do
-    Appsignal.config = project_fixture_config
+    start_agent
   end
 
   context "with redis" do
@@ -19,27 +19,25 @@ describe Appsignal::Hooks::RedisHook do
       end
 
       context "and redis instrumentation enabled" do
-        let(:events) { [] }
         before :all do
           Appsignal.config.config_hash[:instrument_redis] = true
           Appsignal::Hooks::RedisHook.new.install
         end
-        before do
-          ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
-            events << ActiveSupport::Notifications::Event.new(*args)
-          end
-        end
         after(:all) { Object.send(:remove_const, :Redis) }
 
         its(:dependencies_present?) { should be_true }
 
-        it "should generate an event for a redis call" do
+        it "should instrument a redis call" do
+          Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
+          expect( Appsignal::Transaction.current ).to receive(:start_event)
+            .at_least(:once)
+          expect( Appsignal::Transaction.current ).to receive(:finish_event)
+            .at_least(:once)
+            .with('query.redis', nil, nil, 0)
+
           client = Redis::Client.new
 
           client.process([]).should == 1
-
-          event = events.last
-          event.name.should == 'query.redis'
         end
       end
     end

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

@@ -0,0 +1,211 @@
+require 'spec_helper'
+require 'appsignal/integrations/object'
+
+describe Object do
+  describe "#instrument_method" do
+    context "with instance method" do
+      let(:klass) do
+        Class.new do
+          def foo
+            1
+          end
+          appsignal_instrument_method :foo
+        end
+      end
+      let(:instance) { klass.new }
+
+      context "when active" do
+        let(:transaction) { regular_transaction }
+        before { Appsignal.config = project_fixture_config }
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "foo.AnonymousClass.other", nil, nil, 0
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "foo.NamedClass.other", nil, nil, 0
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with nested named class" do
+          before do
+            module MyModule
+              module NestedModule
+                class NamedClass
+                  def bar
+                    2
+                  end
+                  appsignal_instrument_method :bar
+                end
+              end
+            end
+          end
+          after { Object.send(:remove_const, :MyModule) }
+          let(:klass) { MyModule::NestedModule::NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "bar.NamedClass.NestedModule.MyModule.other", nil, nil, 0
+            expect(instance.bar).to eq(2)
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo, name: "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "my_method.group", nil, nil, 0
+            expect(instance.foo).to eq(1)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "should not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_false
+          expect(transaction).to_not receive(:start_event)
+          expect(instance.foo).to eq(1)
+        end
+      end
+    end
+
+    context "with class method" do
+      let(:klass) do
+        Class.new do
+          def self.bar
+            2
+          end
+          appsignal_instrument_class_method :bar
+        end
+      end
+
+      context "when active" do
+        let(:transaction) { regular_transaction }
+        before { Appsignal.config = project_fixture_config }
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "bar.class_method.AnonymousClass.other", nil, nil, 0
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "bar.class_method.NamedClass.other", nil, nil, 0
+            expect(klass.bar).to eq(2)
+          end
+
+          context "with nested named class" do
+            before do
+              module MyModule
+                module NestedModule
+                  class NamedClass
+                    def self.bar
+                      2
+                    end
+                    appsignal_instrument_class_method :bar
+                  end
+                end
+              end
+            end
+            after { Object.send(:remove_const, :MyModule) }
+            let(:klass) { MyModule::NestedModule::NamedClass }
+
+            it "instruments the method and calls it" do
+              expect(Appsignal.active?).to be_true
+              transaction.should_receive(:start_event)
+              transaction.should_receive(:finish_event).with \
+                "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil, 0
+              expect(klass.bar).to eq(2)
+            end
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar, name: "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_true
+            transaction.should_receive(:start_event)
+            transaction.should_receive(:finish_event).with \
+              "my_method.group", nil, nil, 0
+            expect(klass.bar).to eq(2)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "should not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_false
+          expect(transaction).to_not receive(:start_event)
+          expect(klass.bar).to eq(2)
+        end
+      end
+    end
+  end
+end

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

@@ -12,8 +12,8 @@ if sinatra_present? && !padrino_present?
     end
 
     it "should have added the instrumentation middleware" do
-      Sinatra::Application.middleware.to_a.should include(
-        [Appsignal::Rack::SinatraInstrumentation, [], nil]
+      Sinatra::Base.middleware.to_a.should include(
+        [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
       )
     end
   end

data/spec/lib/appsignal/minutely_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Appsignal::Minutely do
+  before do
+    Appsignal::Minutely.probes.clear
+  end
+
+  it "should have a list of probes" do
+    expect( Appsignal::Minutely.probes ).to be_instance_of(Array)
+  end
+
+  describe ".start" do
+    it "should call the probes periodically" do
+      probe = double
+      expect( probe ).to receive(:call).at_least(:twice)
+      Appsignal::Minutely.probes << probe
+      Appsignal::Minutely.stub(:wait_time => 0.1)
+
+      Appsignal::Minutely.start
+
+      sleep 0.5
+    end
+  end
+
+  describe ".wait_time" do
+    it "should get the time to the next minute" do
+      Time.any_instance.stub(:sec => 30)
+      expect( Appsignal::Minutely.wait_time ).to eq 30
+    end
+  end
+
+  describe ".add_gc_probe" do
+    it "should add the gc probe to the list" do
+      expect( Appsignal::Minutely.probes ).to be_empty
+
+      Appsignal::Minutely.add_gc_probe
+
+      expect( Appsignal::Minutely.probes ).to have(1).item
+      expect( Appsignal::Minutely.probes[0] ).to be_instance_of(Appsignal::Minutely::GCProbe)
+    end
+  end
+
+  describe Appsignal::Minutely::GCProbe do
+    describe "#call" do
+      it "should collect GC metrics" do
+        expect(Appsignal).to receive(:set_process_gauge).with('gc.count', kind_of(Integer)).once
+        expect(Appsignal).to receive(:set_process_gauge).with('gc.heap_allocated_pages', kind_of(Integer)).once
+        expect(Appsignal).to receive(:set_process_gauge).at_least(10).times
+
+        Appsignal::Minutely::GCProbe.new.call
+      end
+    end
+  end
+end

data/spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb

@@ -8,6 +8,35 @@ end
 
 if defined?(::Sinatra)
   describe Appsignal::Rack::SinatraInstrumentation do
+    let(:settings) { double(:raise_errors => false) }
+    let(:app) { double(:call => true, :settings => settings) }
+    let(:env) { {'sinatra.route' => 'GET /', :path => '/', :method => 'GET'} }
+    let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
+
+    describe "#call" do
+      before do
+        start_agent
+        middleware.stub(:raw_payload => {})
+        Appsignal.stub(:active? => true)
+      end
+
+      it "should call without monitoring" do
+        expect(Appsignal::Transaction).to_not receive(:create)
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe ".settings" do
+      subject { middleware.settings }
+
+      it "should return the app's settings" do
+        expect(subject).to eq(app.settings)
+      end
+    end
+  end
+
+  describe Appsignal::Rack::SinatraBaseInstrumentation do
     before :all do
       start_agent
     end
@@ -16,7 +45,7 @@ if defined?(::Sinatra)
     let(:app) { double(:call => true, :settings => settings) }
     let(:env) { {'sinatra.route' => 'GET /', :path => '/', :method => 'GET'} }
     let(:options) { {} }
-    let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app, options) }
+    let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
     describe "#call" do
       before do
@@ -99,8 +128,26 @@ if defined?(::Sinatra)
         end
       end
 
-      it "should set the action" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with('GET /')
+      describe "action name" do
+        it "should set the action" do
+          Appsignal::Transaction.any_instance.should_receive(:set_action).with('GET /')
+        end
+
+        context "with option to set path a mounted_at prefix" do
+          let(:options) {{ :mounted_at  => "/api/v2" }}
+
+          it "should call set_action with a prefix path" do
+            Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /api/v2/")
+          end
+        end
+
+        context "with mounted modular application" do
+          before { env['SCRIPT_NAME'] = '/api' }
+
+          it "should call set_action with an application prefix path" do
+            Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /api/")
+          end
+        end
       end
 
       it "should set metadata" do
@@ -123,13 +170,6 @@ if defined?(::Sinatra)
         end
       end
 
-      context "with option to set path prefix" do
-        let(:options) {{ :mounted_at  => "/api/v2" }}
-        it "should call set_action with a prefix path" do
-          Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /api/v2/")
-        end
-      end
-
       after { middleware.call(env) rescue VerySpecificError }
     end
   end

data/spec/lib/appsignal/subscriber_spec.rb

@@ -116,17 +116,16 @@ describe Appsignal::Subscriber do
       it "should call finish with title and body if there is a formatter" do
         transaction.should_receive(:start_event).once
         transaction.should_receive(:finish_event).with(
-          'request.net_http',
+          'request.faraday',
+          'GET http://www.google.com',
           'GET http://www.google.com',
-          nil,
           nil
         ).once
 
         ActiveSupport::Notifications.instrument(
-          'request.net_http',
-          :protocol => 'http',
-          :domain   => 'www.google.com',
-          :method   => 'GET'
+          'request.faraday',
+          :method => 'get',
+          :url => URI('http://www.google.com')
         )
       end
 

data/spec/lib/appsignal/transaction_spec.rb

@@ -24,7 +24,6 @@ describe Appsignal::Transaction do
 
   context "class methods" do
     describe ".create" do
-
       it "should add the transaction to thread local" do
         Appsignal::Extension.should_receive(:start_transaction).with('1', 'http_request')
 
@@ -447,7 +446,7 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe "finish_event" do
+    describe "#finish_event" do
       it "should finish the event in the extension" do
         transaction.ext.should_receive(:finish_event).with(
           'name',
@@ -481,6 +480,63 @@ describe Appsignal::Transaction do
       end
     end
 
+    describe "#record_event" do
+      it "should record the event in the extension" do
+        transaction.ext.should_receive(:record_event).with(
+          'name',
+          'title',
+          'body',
+          1000,
+          1
+        )
+
+        transaction.record_event(
+          'name',
+          'title',
+          'body',
+          1000,
+          1
+        )
+      end
+
+      it "should finish the event in the extension with nil arguments" do
+        transaction.ext.should_receive(:record_event).with(
+          'name',
+          '',
+          '',
+          1000,
+          0
+        )
+
+        transaction.record_event(
+          'name',
+          nil,
+          nil,
+          1000,
+          nil
+        )
+      end
+    end
+
+    describe "#instrument" do
+      it "should start and finish an event around the given block" do
+        stub = double
+        stub.should_receive(:method_call).and_return('return value')
+
+        transaction.should_receive(:start_event)
+        transaction.should_receive(:finish_event).with(
+          'name',
+          'title',
+          'body',
+          0
+        )
+
+        transaction.instrument 'name', 'title', 'body' do
+          stub.method_call
+        end.should eq 'return value'
+      end
+    end
+
     context "generic request" do
       let(:env) { {} }
       subject { Appsignal::Transaction::GenericRequest.new(env) }
@@ -595,38 +651,61 @@ describe Appsignal::Transaction do
         it { should be_nil }
       end
 
-      context "when not sending params" do
-        before { Appsignal.config.config_hash[:send_params] = false }
-        after { Appsignal.config.config_hash[:send_params] = true }
+      context "when params method does not exist" do
+        let(:options) { {:params_method => :nonsense} }
 
         it { should be_nil }
       end
 
-      context "when params method does not exist" do
-        let(:options) { {:params_method => :nonsense} }
+      context "when not sending params" do
+        before { Appsignal.config.config_hash[:send_params] = false }
+        after { Appsignal.config.config_hash[:send_params] = true }
 
         it { should be_nil }
       end
 
       context "with an array" do
-        let(:request) { Appsignal::Transaction::GenericRequest.new(background_env_with_data(:params => ['arg1', 'arg2'])) }
+        let(:request) do
+          Appsignal::Transaction::GenericRequest.new(background_env_with_data(:params => ['arg1', 'arg2']))
+        end
 
         it { should == ['arg1', 'arg2'] }
+
+        context "with AppSignal filtering" do
+          before { Appsignal.config.config_hash[:filter_parameters] = %w(foo) }
+          after { Appsignal.config.config_hash[:filter_parameters] = [] }
+
+          it { should == ['arg1', 'arg2'] }
+        end
       end
 
       context "with env" do
-        it "should call the params sanitizer" do
-          Appsignal::ParamsSanitizer.should_receive(:sanitize).with(kind_of(Hash)).and_return({
-            'controller' => 'blog_posts',
-            'action' => 'show',
-            'id' => '1'
-          })
-
-          subject.should == {
-            'controller' => 'blog_posts',
-            'action' => 'show',
-            'id' => '1'
-          }
+        context "with sanitization" do
+          let(:request) do
+            Appsignal::Transaction::GenericRequest.new \
+              http_request_env_with_data(:params => { :foo => :bar })
+          end
+
+          it "should call the params sanitizer" do
+            puts Appsignal.config.config_hash[:filter_parameters].inspect
+            subject.should == { :foo => :bar }
+          end
+        end
+
+        context "with AppSignal filtering" do
+          let(:request) do
+            Appsignal::Transaction::GenericRequest.new \
+              http_request_env_with_data(:params => { :foo => :bar, :baz => :bat })
+          end
+          before { Appsignal.config.config_hash[:filter_parameters] = %w(foo) }
+          after { Appsignal.config.config_hash[:filter_parameters] = [] }
+
+          it "should call the params sanitizer with filtering" do
+            subject.should == {
+              :foo => '[FILTERED]',
+              :baz => :bat
+            }
+          end
         end
       end
     end
@@ -684,7 +763,7 @@ describe Appsignal::Transaction do
         end
 
         it "passes the session data into the params sanitizer" do
-          Appsignal::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
+          Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
             and_return(:sanitized_foo)
           subject.should == :sanitized_foo
         end
@@ -698,7 +777,7 @@ describe Appsignal::Transaction do
             end
 
             it "should return an session hash" do
-              Appsignal::ParamsSanitizer.should_receive(:sanitize).with({'foo' => :bar}).
+              Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with({'foo' => :bar}).
                 and_return(:sanitized_foo)
               subject
             end
@@ -719,7 +798,7 @@ describe Appsignal::Transaction do
           end
 
           it "does not pass the session data into the params sanitizer" do
-            Appsignal::ParamsSanitizer.should_not_receive(:sanitize)
+            Appsignal::Utils::ParamsSanitizer.should_not_receive(:sanitize)
             subject.should be_nil
           end
         end