appsignal 1.0.7 → 1.1.0.beta.1

data/spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb

@@ -4,7 +4,7 @@ describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
   let(:klass)     { Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter }
   let(:formatter) { klass.new }
 
-  it "should register instantiation.active_record" do
+  it "should register request.net_http" do
     Appsignal::EventFormatter.registered?('instantiation.active_record', klass).should be_true
   end
 

data/spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb

@@ -1,23 +1,195 @@
 require 'spec_helper'
 
-describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
-  let(:klass)     { Appsignal::EventFormatter::ActiveRecord::SqlFormatter }
-  let(:formatter) { klass.new }
+if active_record_present?
+  require 'active_record'
 
-  it "should register sql.active_record" do
-    Appsignal::EventFormatter.registered?('sql.active_record', klass).should be_true
-  end
+  describe Appsignal::EventFormatter::ActiveRecord::SqlFormatter do
+    let(:klass) { Appsignal::EventFormatter::ActiveRecord::SqlFormatter }
+    let(:formatter) { klass.new }
+    let(:connection_config) { {} }
+    before do
+      if ActiveRecord::Base.respond_to?(:connection_config)
+        # Rails 3.1+
+        ActiveRecord::Base.stub(
+          :connection_config => connection_config
+        )
+      else
+        # Rails 3.0
+        spec = double(:config => connection_config)
+        ActiveRecord::Base.stub(
+          :connection_pool => double(:spec => spec)
+        )
+      end
+    end
+
+    pending "should register sql.activerecord" do
+      Appsignal::EventFormatter.registered?('sql.active_record', klass).should be_true
+    end
+
+    context "if a connection cannot be established" do
+      before do
+        ActiveRecord::Base.stub(:connection_config).and_raise(ActiveRecord::ConnectionNotEstablished)
+      end
+
+      it "should log the error and unregister the formatter" do
+        Appsignal.logger.should_receive(:error).with(
+          'Error while getting ActiveRecord connection info, unregistering sql.active_record event formatter'
+        )
+
+        lambda {
+          formatter
+        }.should_not raise_error
 
-  describe "#format" do
-    let(:payload) do
-      {
-        name: 'User load',
-        sql: 'SELECT * FROM users'
-      }
+        Appsignal::EventFormatter.registered?('sql.active_record').should be_false
+      end
     end
 
-    subject { formatter.format(payload) }
+    describe "#format" do
+      let(:name) { 'Model load' }
+      let(:payload) { {:sql => sql, :name => name} }
+      subject { formatter.format(payload) }
+
+      context "with backtick table names" do
+        before { formatter.stub(:adapter_uses_double_quoted_table_names => false) }
+
+        context "single quoted data value" do
+          let(:sql) { "SELECT `table`.* FROM `table` WHERE `id` = 'secret' ORDER BY `table`.`id` ASC LIMIT 1" }
+
+          it { should == ['Model load', "SELECT `table`.* FROM `table` WHERE `id` = ? ORDER BY `table`.`id` ASC LIMIT ?"] }
+
+          context "with escaped single quotes in the string" do
+            let(:sql) { "`id` = 'this is a \'big\' secret'" }
+
+            it { should == ['Model load', "`id` = ?"] }
+          end
+        end
+
+        context "double quoted data value" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = "secret"' }
+
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` = ?'] }
+
+          context "with escaped double quotes in the string" do
+            let(:sql) { '`id` = "this is a \"big\" secret"' }
+
+            it { should == ['Model load', "`id` = ?"] }
+          end
+        end
+
+        context "numeric parameter" do
+          context "integer" do
+            let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = 1' }
+
+            it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` = ?'] }
+          end
+
+          context "float" do
+            let(:sql) { 'SELECT `table`.* FROM `table` WHERE `value` = 10.0' }
+
+            it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `value` = ?'] }
+          end
+        end
+
+        context "in operator with values" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` IN (1, 2)' }
+
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` IN (?)'] }
+        end
+
+        context "in operator with inner query" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` IN (SELECT `id` from `other_table` WHERE `value` = 10.0)' }
+
+          it { should == ['Model load', 'SELECT `table`.* FROM `table` WHERE `id` IN (SELECT `id` from `other_table` WHERE `value` = ?)'] }
+        end
+      end
+
+      context "with double quote style table names" do
+        let(:connection_config) { {:adapter => 'postgresql'} }
+
+        context "single quoted data value" do
+          let(:sql) { "SELECT \"table\".* FROM \"table\" WHERE \"id\" = 'secret' ORDER BY \"table\".\"id\" ASC LIMIT 1" }
+
+          it { should == ['Model load', "SELECT \"table\".* FROM \"table\" WHERE \"id\" = ? ORDER BY \"table\".\"id\" ASC LIMIT ?"] }
 
-    it { should == ['User load', 'SELECT * FROM users', 1] }
+          context "with an escaped single quote" do
+            let(:sql) { "\"id\" = 'this is a \'big\' secret'" }
+
+            it { should == ['Model load', "\"id\" = ?"] }
+          end
+        end
+
+        context "numeric parameter" do
+          context "integer" do
+            let(:sql) { 'SELECT "table".* FROM "table" WHERE "id"=1' }
+
+            it { should == ['Model load', 'SELECT "table".* FROM "table" WHERE "id"=?'] }
+          end
+
+          context "float" do
+            let(:sql) { 'SELECT "table".* FROM "table" WHERE "value"=10.0' }
+
+            it { should == ['Model load', 'SELECT "table".* FROM "table" WHERE "value"=?'] }
+          end
+        end
+      end
+
+      context "return nil for schema queries" do
+        let(:name) { 'SCHEMA' }
+        let(:sql) { 'SET client_min_messages TO 22' }
+
+        it { should be_nil }
+      end
+
+      context "with a a frozen sql string" do
+        let(:sql) { "SELECT `table`.* FROM `table` WHERE `id` = 'secret'".freeze }
+
+        it { should == ['Model load', "SELECT `table`.* FROM `table` WHERE `id` = ?"] }
+      end
+    end
+
+    describe "#schema_query?" do
+      let(:payload) { {} }
+      subject { formatter.send(:schema_query?, payload) }
+
+      it { should be_false }
+
+      context "when name is schema" do
+        let(:payload) { {:name => 'SCHEMA'} }
+
+        it { should be_true }
+      end
+    end
+
+    context "connection config" do
+      describe "#connection_config" do
+        let(:connection_config) { {:adapter => 'adapter'} }
+
+        subject { formatter.send(:connection_config) }
+
+        it { should == {:adapter => 'adapter'} }
+      end
+
+      describe "#adapter_uses_double_quoted_table_names" do
+        subject { formatter.adapter_uses_double_quoted_table_names }
+
+        context "when using mysql" do
+          let(:connection_config) { {:adapter => 'mysql'} }
+
+          it { should be_false }
+        end
+
+        context "when using postgresql" do
+          let(:connection_config) { {:adapter => 'postgresql'} }
+
+          it { should be_true }
+        end
+
+        context "when using sqlite" do
+          let(:connection_config) { {:adapter => 'sqlite'} }
+
+          it { should be_true }
+        end
+      end
+    end
   end
 end

data/spec/lib/appsignal/event_formatter/elastic_search/search_formatter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Appsignal::EventFormatter::ElasticSearch::SearchFormatter do
+  let(:klass)     { Appsignal::EventFormatter::ElasticSearch::SearchFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register query.moped" do
+    expect(
+      Appsignal::EventFormatter.registered?('search.elasticsearch', klass)
+    ).to be_true
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        :name   => 'Search',
+        :klass  => 'User',
+        :search => {:index => 'users', :type => 'user', :q => 'John Doe'}
+      }
+    end
+
+    it "should return a payload with name and sanitized body" do
+      expect( formatter.format(payload) ).to eql([
+        "Search: User",
+        "{:index=>\"users\", :type=>\"user\", :q=>\"?\"}"
+      ])
+    end
+  end
+
+  describe "#sanitized_search" do
+    let(:search) do
+      {
+        :index => 'users',
+        :type  => 'user',
+        :q     => 'John Doe',
+        :other => 'Other'
+      }
+    end
+
+    it "should sanitize non-whitelisted params" do
+      expect(
+        formatter.sanitized_search(search)
+      ).to eql({:index => 'users', :type => 'user', :q => '?', :other => '?'})
+    end
+
+    it "should return nil string when search is nil" do
+      expect( formatter.sanitized_search(nil) ).to be_nil
+    end
+
+    it "should return nil string when search is not a hash" do
+      expect( formatter.sanitized_search([]) ).to be_nil
+    end
+  end
+end

data/spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb

@@ -22,12 +22,12 @@ describe Appsignal::EventFormatter::Moped::QueryFormatter do
       let(:op) do
         double(
           :full_collection_name => 'database.collection',
-          :selector             => {'query' => {'_id' => 'abc'}},
+          :selector             => {'_id' => 'abc'},
           :class                => double(:to_s => 'Moped::Protocol::Command')
         )
       end
 
-      it { should == ['Command', '{:database=>"database.collection", :selector=>{"query"=>"?"}}'] }
+      it { should == ['Command', '{:database=>"database.collection", :selector=>{"_id"=>"?"}}'] }
     end
 
     context "Moped::Protocol::Query" do
@@ -80,13 +80,13 @@ describe Appsignal::EventFormatter::Moped::QueryFormatter do
         double(
           :full_collection_name => 'database.collection',
           :selector             => {'_id' => 'abc'},
-          :update               => {'user.name' => 'James Bond'},
+          :update               => {'name' => 'James Bond'},
           :flags                => [],
           :class                => double(:to_s => 'Moped::Protocol::Update')
         )
       end
 
-      it { should == ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"user.?"=>"?"}, :flags=>[]}'] }
+      it { should == ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"name"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::KillCursors" do

data/spec/lib/appsignal/extension_spec.rb

@@ -46,7 +46,7 @@ describe "extension loading and operation" do
       end
 
       it "should have a finish_event method" do
-        subject.finish_event(1, 'name', 'title', 'body', 0)
+        subject.finish_event(1, 'name', 'title', 'body')
       end
 
       it "should have a set_transaction_error method" do

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

@@ -28,17 +28,18 @@ describe Appsignal::Hooks::DelayedJobHook do
     describe ".invoke_with_instrumentation" do
       let(:plugin) { Appsignal::Hooks::DelayedJobPlugin }
       let(:time) { Time.parse('01-01-2001 10:01:00UTC') }
-      let(:job) do
-        double(
+      let(:job_data) do
+        {
           :id             => 123,
           :name           => 'TestClass#perform',
           :priority       => 1,
           :attempts       => 1,
           :queue          => 'default',
           :created_at     => time - 60_000,
-          :payload_object => double
-        )
+          :payload_object => double(:args => ['argument']),
+        }
       end
+      let(:job) { double(job_data) }
       let(:invoked_block) { Proc.new { } }
       let(:error) { StandardError.new }
 
@@ -54,6 +55,7 @@ describe Appsignal::Hooks::DelayedJobHook do
               :queue    => 'default',
               :id       => '123'
             },
+            :params      => ['argument'],
             :queue_start => time - 60_000,
           )
 
@@ -63,18 +65,19 @@ describe Appsignal::Hooks::DelayedJobHook do
         end
 
         context "with custom name call" do
-          let(:job) do
-            double(
+          let(:job_data) do
+            {
               :payload_object => double(
-                :appsignal_name => 'CustomClass#perform'
+                :appsignal_name => 'CustomClass#perform',
+                :args           => ['argument']
               ),
-              :id         => '123',
-              :name       => 'TestClass#perform',
-              :priority   => 1,
-              :attempts   => 1,
-              :queue      => 'default',
-              :created_at => time - 60_000
-            )
+              :id             => '123',
+              :name           => 'TestClass#perform',
+              :priority       => 1,
+              :attempts       => 1,
+              :queue          => 'default',
+              :created_at     => time - 60_000
+            }
           end
           it "should wrap in a transaction with the correct params" do
             Appsignal.should_receive(:monitor_transaction).with(
@@ -87,6 +90,7 @@ describe Appsignal::Hooks::DelayedJobHook do
                 :queue    => 'default',
                 :id       => '123'
               },
+              :params      => ['argument'],
               :queue_start => time - 60_000
             )
 
@@ -95,6 +99,37 @@ describe Appsignal::Hooks::DelayedJobHook do
             end
           end
         end
+
+        if active_job_present?
+          require 'active_job'
+
+          context "when wrapped by ActiveJob" do
+            before do
+              job_data[:args] = ['argument']
+            end
+            let(:job) { ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(job_data) }
+
+            it "should wrap in a transaction with the correct params" do
+              Appsignal.should_receive(:monitor_transaction).with(
+                'perform_job.delayed_job',
+                :class    => 'TestClass',
+                :method   => 'perform',
+                :metadata => {
+                  :priority => 1,
+                  :attempts => 1,
+                  :queue    => 'default',
+                  :id       => '123'
+                },
+                :params      => ['argument'],
+                :queue_start => time - 60_000,
+              )
+
+              Timecop.freeze(time) do
+                plugin.invoke_with_instrumentation(job, invoked_block)
+              end
+            end
+          end
+        end
       end
 
       context "with an erroring call" do

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

@@ -15,7 +15,7 @@ describe "Sequel integration", if: sequel_present? do
         .at_least(:once)
       expect( Appsignal::Extension ).to receive(:finish_event)
         .at_least(:once)
-        .with(kind_of(Integer), "sql.sequel", "", kind_of(String), 1)
+        .with(kind_of(Integer), "sql.sequel", "", "")
 
       db['SELECT 1'].all
     end

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

@@ -36,21 +36,35 @@ describe Appsignal::Hooks::SidekiqPlugin do
       )
     end
 
-    it "reports the correct job class for a ActiveJob wrapped job" do
-      item['wrapped'] = 'ActiveJobClass'
-      Appsignal.should_receive(:monitor_transaction).with(
-        'perform_job.sidekiq',
-        :class    => 'ActiveJobClass',
-        :method   => 'perform',
-        :metadata => {
-          'retry_count' => "0",
-          'queue'       => 'default',
-          'extra'       => 'data',
-          'wrapped'     => 'ActiveJobClass'
-        },
-        :params      => ['Model', "1"],
-        :queue_start => Time.parse('01-01-2001 10:00:00UTC')
-      )
+    context "when wrapped by ActiveJob" do
+      let(:item) {{
+        "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
+        "wrapped" => "TestClass",
+        "queue" => "default",
+        "args"=> [{
+          "job_class" => "TestJob",
+          "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
+          "queue_name" => "default",
+          "arguments" => ['Model', 1],
+        }],
+        "retry" => true,
+        "jid" => "efb140489485999d32b5504c",
+        "created_at" => Time.parse('01-01-2001 10:00:00UTC').to_f,
+        "enqueued_at" => Time.parse('01-01-2001 10:00:00UTC').to_f
+      }}
+
+      it "should wrap in a transaction with the correct params" do
+        Appsignal.should_receive(:monitor_transaction).with(
+          'perform_job.sidekiq',
+          :class    => 'TestClass',
+          :method   => 'perform',
+          :metadata => {
+            'queue' => 'default'
+          },
+          :params      => ['Model', "1"],
+          :queue_start => Time.parse('01-01-2001 10:00:00UTC').to_f
+        )
+      end
     end
 
     after do
@@ -92,53 +106,6 @@ describe Appsignal::Hooks::SidekiqPlugin do
       plugin.formatted_metadata(item).should == {'foo' => 'bar'}
     end
   end
-
-  describe "#format_args" do
-    let(:object) { Object.new }
-    let(:args) do
-      [
-        'Model',
-        1,
-        object
-      ]
-    end
-
-    it "should format the arguments" do
-      plugin.format_args(args).should == ['Model', '1', object.inspect]
-    end
-  end
-
-  describe "#truncate" do
-    let(:very_long_text) do
-      "a" * 400
-    end
-
-    it "should truncate the text to 200 chars max" do
-      plugin.truncate(very_long_text).should == "#{'a' * 197}..."
-    end
-  end
-
-  describe "#string_or_inspect" do
-    context "when string" do
-      it "should return the string" do
-        plugin.string_or_inspect('foo').should == 'foo'
-      end
-    end
-
-    context "when integer" do
-      it "should return the string" do
-        plugin.string_or_inspect(1).should == '1'
-      end
-    end
-
-    context "when object" do
-      let(:object) { Object.new }
-
-      it "should return the string" do
-        plugin.string_or_inspect(object).should == object.inspect
-      end
-    end
-  end
 end
 
 describe Appsignal::Hooks::SidekiqHook do