appsignal 1.0.4 → 1.0.5.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0350232f5d3a6ec3503533f55ec40e31f7f8d332
-  data.tar.gz: d0a7745539d05747eb88f2b43469c73b8902f0bd
+  metadata.gz: 60c1db0e297973e3f82bb7f4e066f81e7f3aa21b
+  data.tar.gz: 1ac6c8bd4fc0e5d427c92fde8c1fa2a277137f02
 SHA512:
-  metadata.gz: 2a29b7d6750d40d67889cf456f5f161b7c5f64fb405ce54c9986649b9179895560429b920568b1ca8ea947e8e38993b86086727315121a24fea2311d85b6bbc9
-  data.tar.gz: 396c3d1e3a5370363e4e0ae777e1c767cfb58a611103f5af939aa0d552b646998b36d40aa2b996b2b558c9aad9d0422ba619973dfaaac574c699fc32d19a2039
+  metadata.gz: b92b2e03ddd2ab61e795545deb0241e7bb87270389bd558b9b6bb2b72da38f3a91b6171b595df64b0b2f498a9345622afb3048cbf9cde4363e0df413a38dbd09
+  data.tar.gz: d26efb030425c886260fd4e0fa9788127dd4bb829bc4bb9e8efc44e041e92d03be44a0246b54aadec6b7b9b72c9be703d60de48efdff428213d523a2a557d69e

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.0.5
+* Improved sql sanitization
+* Improved mongoid/mongodb sanitization
+* Minor performance improvements
+
 # 1.0.4
 * Make working dir configurable using `APPSIGNAL_WORKING_DIR_PATH` or `:working_dir_path`
 

data/ext/agent.yml

@@ -1,15 +1,15 @@
 ---
-version: '2038949'
+version: 6b0801e
 triples:
   x86_64-linux:
-    checksum: 947bd26d16a70d059520ad30d651acfe50be30868b470d7b0d7ebfdd6d28d189
-    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/2038949/appsignal-agent-x86_64-linux-static.tar.gz
+    checksum: 510a28ef2d76351ca308ebf8950ad50e8c93b4ec955c25f72b658f3ab009d42b
+    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/6b0801e/appsignal-agent-x86_64-linux-static.tar.gz
     lib_filename: libappsignal.a
   i686-linux:
-    checksum: 43ebd910b46886cacef6ecc6ac719f0aa8d268e4e49c73cd43814ef76688f319
-    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/2038949/appsignal-agent-i686-linux-static.tar.gz
+    checksum: 7aed9373264128c38c515463c671fba03db2fbc863c85bae77c56a2d240ac86f
+    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/6b0801e/appsignal-agent-i686-linux-static.tar.gz
     lib_filename: libappsignal.a
   x86_64-darwin:
-    checksum: 37aee7a624471ea5257fa0118531bc585d832c9b255e64d924b6fc1c85e2baa7
-    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/2038949/appsignal-agent-x86_64-darwin-static.tar.gz
+    checksum: 60ac2a74933d9ac58f441f6ee3f875f5c0cbdee24b6b671f7fc81db992ea117c
+    download_url: https://appsignal-agent-releases.global.ssl.fastly.net/6b0801e/appsignal-agent-x86_64-darwin-static.tar.gz
     lib_filename: libappsignal.a

data/ext/appsignal_extension.c

@@ -26,17 +26,19 @@ static VALUE start_event(VALUE self, VALUE transaction_index) {
   return Qnil;
 }
 
-static VALUE finish_event(VALUE self, VALUE transaction_index, VALUE name, VALUE title, VALUE body) {
+static VALUE finish_event(VALUE self, VALUE transaction_index, VALUE name, VALUE title, VALUE body, VALUE body_format) {
   Check_Type(transaction_index, T_FIXNUM);
   Check_Type(name, T_STRING);
   Check_Type(title, T_STRING);
   Check_Type(body, T_STRING);
+  Check_Type(body_format, T_FIXNUM);
 
   appsignal_finish_event(
       FIX2INT(transaction_index),
       StringValueCStr(name),
       StringValueCStr(title),
-      StringValueCStr(body)
+      StringValueCStr(body),
+      FIX2INT(body_format)
   );
   return Qnil;
 }
@@ -216,7 +218,7 @@ void Init_appsignal_extension(void) {
   rb_define_singleton_method(Extension, "stop",                        stop,                        0);
   rb_define_singleton_method(Extension, "start_transaction",           start_transaction,           2);
   rb_define_singleton_method(Extension, "start_event",                 start_event,                 1);
-  rb_define_singleton_method(Extension, "finish_event",                finish_event,                4);
+  rb_define_singleton_method(Extension, "finish_event",                finish_event,                5);
   rb_define_singleton_method(Extension, "set_transaction_error",       set_transaction_error,       4);
   rb_define_singleton_method(Extension, "set_transaction_sample_data", set_transaction_sample_data, 3);
   rb_define_singleton_method(Extension, "set_transaction_action",      set_transaction_action,      2);

data/lib/appsignal/event_formatter.rb

@@ -60,6 +60,8 @@ module Appsignal
       end
     end
   end
+
+  SQL_BODY_FORMAT = 1
 end
 
 Dir.glob(File.expand_path('../event_formatter/**/*.rb', __FILE__)).each do |file|

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -4,55 +4,9 @@ module Appsignal
       class SqlFormatter < Appsignal::EventFormatter
         register 'sql.active_record'
 
-        SINGLE_QUOTED_STRING = /'(.?|[^']).*'/.freeze
-        DOUBLE_QUOTED_STRING = /"(.?|[^"]).*"/.freeze
-        IN_OPERATOR_CONTENT  = /(IN \()[^SELECT][^\)]+(\))/.freeze
-        NUMERIC              = /\d*\.?\d+/.freeze
-        REPLACEMENT          = '?'.freeze
-        IN_REPLACEMENT       = '\1?\2'.freeze
-        SCHEMA               = 'SCHEMA'.freeze
-
-        attr_reader :adapter_uses_double_quoted_table_names
-
-        def initialize
-          @connection_config = connection_config
-          @adapter_uses_double_quoted_table_names = adapter_uses_double_quoted_table_names?
-        rescue ::ActiveRecord::ConnectionNotEstablished
-          Appsignal::EventFormatter.unregister('sql.active_record', self.class)
-          Appsignal.logger.error('Error while getting ActiveRecord connection info, unregistering sql.active_record event formatter')
-        end
-
         def format(payload)
-          return nil if schema_query?(payload) || !payload[:sql]
-          sql_string = payload[:sql].dup
-          unless adapter_uses_double_quoted_table_names
-            sql_string.gsub!(DOUBLE_QUOTED_STRING, REPLACEMENT)
-          end
-          sql_string.gsub!(SINGLE_QUOTED_STRING, REPLACEMENT)
-          sql_string.gsub!(IN_OPERATOR_CONTENT, IN_REPLACEMENT)
-          sql_string.gsub!(NUMERIC, REPLACEMENT)
-          [payload[:name], sql_string]
+          [payload[:name], payload[:sql], SQL_BODY_FORMAT]
         end
-
-        protected
-
-          def schema_query?(payload)
-            payload[:name] == SCHEMA
-          end
-
-          def connection_config
-            # TODO handle ActiveRecord::ConnectionNotEstablished
-            if ::ActiveRecord::Base.respond_to?(:connection_config)
-              ::ActiveRecord::Base.connection_config
-            else
-              ::ActiveRecord::Base.connection_pool.spec.config
-            end
-          end
-
-          def adapter_uses_double_quoted_table_names?
-            adapter = @connection_config[:adapter]
-            adapter =~ /postgres/ || adapter =~ /sqlite/
-          end
       end
     end
   end

data/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter.rb

@@ -0,0 +1,88 @@
+module Appsignal
+  class EventFormatter
+    module MongoRubyDriver
+      class QueryFormatter
+        ALLOWED = {
+          "find" => {
+            "find"   => :allow,
+            "filter" => :sanitize_document
+          },
+          "count" => {
+            "count" => :allow,
+            "query" => :sanitize_document
+          },
+          "distinct" => {
+            "distinct" => :allow,
+            "key"      => :allow,
+            "query"    => :sanitize_document
+          },
+          "insert" => {
+            "insert"    => :allow,
+            "documents" => :deny_array,
+            "ordered"   => :allow
+          },
+          "update" => {
+            "update"  => :allow,
+            "updates" => :sanitize_bulk,
+            "ordered" => :allow
+          },
+          "findandmodify" => {
+            "findandmodify" => :allow,
+            "query"         => :sanitize_document,
+            "update"        => :deny_array,
+            "new"           => :allow
+          },
+          "delete" => {
+            "delete" => :allow,
+            "deletes" => :sanitize_bulk,
+            "ordered" => :allow
+          },
+          "bulk" => {
+            "q"      => :sanitize_document,
+            "u"      => :deny_array,
+            "limit"  => :allow,
+            "multi"  => :allow,
+            "upsert" => :allow
+          }
+        }
+
+        # Format command based on given strategy
+        def self.format(strategy, command)
+          # Stop processing if command is not a hash
+          return {} unless command.is_a?(Hash)
+
+          # Get the strategy and stop if it's not present
+          strategies = ALLOWED[strategy.to_s]
+          return {} unless strategies
+
+          {}.tap do |hsh|
+            command.each do |key, val|
+              hsh[key] = self.apply_strategy(strategies[key], val)
+            end
+          end
+        end
+
+        # Applies strategy on hash values based on keys
+        def self.apply_strategy(strategy, val)
+          case strategy
+          when :allow      then val
+          when :deny       then '?'
+          when :deny_array then '[?]'
+          when :sanitize_document
+            Appsignal::Utils.sanitize(val, true, :mongodb)
+          when :sanitize_bulk
+            if val.length > 1
+              [
+                self.format(:bulk, val.first),
+                "[...]"
+              ]
+            else
+              val.map { |v| self.format(:bulk, v) }
+            end
+          else '?'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/moped/query_formatter.rb

@@ -11,12 +11,12 @@ module Appsignal
             when 'Moped::Protocol::Command'
               return ['Command', {
                 :database => op.full_collection_name,
-                :selector => Appsignal::Utils.sanitize(op.selector)
+                :selector => Appsignal::Utils.sanitize(op.selector, true, :mongodb)
               }.inspect]
             when 'Moped::Protocol::Query'
               return ['Query', {
                 :database => op.full_collection_name,
-                :selector => Appsignal::Utils.sanitize(op.selector),
+                :selector => Appsignal::Utils.sanitize(op.selector, false, :mongodb),
                 :flags    => op.flags,
                 :limit    => op.limit,
                 :skip     => op.skip,
@@ -25,21 +25,21 @@ module Appsignal
             when 'Moped::Protocol::Delete'
               return ['Delete', {
                 :database => op.full_collection_name,
-                :selector => Appsignal::Utils.sanitize(op.selector),
+                :selector => Appsignal::Utils.sanitize(op.selector, false, :mongodb),
                 :flags    => op.flags,
               }.inspect]
             when 'Moped::Protocol::Insert'
               return ['Insert', {
                 :database   => op.full_collection_name,
-                :documents  => Appsignal::Utils.sanitize(op.documents, true),
+                :documents  => Appsignal::Utils.sanitize(op.documents, true, :mongodb),
                 :count      => op.documents.count,
                 :flags      => op.flags,
               }.inspect]
             when 'Moped::Protocol::Update'
               return ['Update', {
                 :database => op.full_collection_name,
-                :selector => Appsignal::Utils.sanitize(op.selector),
-                :update   => Appsignal::Utils.sanitize(op.update, true),
+                :selector => Appsignal::Utils.sanitize(op.selector, false, :mongodb),
+                :update   => Appsignal::Utils.sanitize(op.update, true, :mongodb),
                 :flags    => op.flags,
               }.inspect]
             when 'Moped::Protocol::KillCursors'
@@ -53,7 +53,6 @@ module Appsignal
             end
           end
         end
-
       end
     end
   end

data/lib/appsignal/event_formatter/sequel/sql_formatter.rb

@@ -0,0 +1,13 @@
+module Appsignal
+  class EventFormatter
+    module Sequel
+      class SqlFormatter < Appsignal::EventFormatter
+        register 'sql.sequel'
+
+        def format(payload)
+          [nil, payload[:sql], SQL_BODY_FORMAT]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/sequel.rb

@@ -3,13 +3,10 @@ module Appsignal
     module SequelExtension
       # Add query instrumentation
       def log_yield(sql, args = nil)
-
-        # We'd like to get full sql queries in the payloads as well. To do
-        # that we need to find out a way to ask Sequel which quoting strategy
-        # is used by the adapter. We can then do something similar to the AR
-        # formatter.
-
-        ActiveSupport::Notifications.instrument('sql.sequel') do
+        ActiveSupport::Notifications.instrument(
+          'sql.sequel',
+          :sql => sql
+        ) do
           yield
         end
       end

data/lib/appsignal/integrations/capistrano/appsignal.cap

@@ -1,6 +1,6 @@
 namespace :appsignal do
   task :deploy do
-    env = fetch(:rails_env, fetch(:rack_env, 'production'))
+    env = fetch(:stage, fetch(:rails_env, fetch(:rack_env, 'production')))
     user = ENV['USER'] || ENV['USERNAME']
     revision = fetch(:appsignal_revision, fetch(:current_revision))
     logger = fetch(:logger, Logger.new($stdout))

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -1,16 +1,19 @@
 module Appsignal
   class Hooks
     class MongoMonitorSubscriber
-
       # Called by Mongo::Monitor when query starts
       def started(event)
         transaction = Appsignal::Transaction.current
         return if transaction.nil_transaction?
         return if transaction.paused?
 
+        # Format the command
+        command = Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
+          .format(event.command_name, event.command)
+
         # Store the query on the transaction, we need it when the event finishes
         store                   = transaction.store('mongo_driver')
-        store[event.request_id] = Appsignal::Utils.sanitize(event.command)
+        store[event.request_id] = command
 
         # Start this event
         Appsignal::Extension.start_event(transaction.transaction_index)
@@ -36,14 +39,15 @@ module Appsignal
 
         # Get the query from the transaction store
         store   = transaction.store('mongo_driver')
-        command = store[event.request_id].inspect
+        command = store.delete(event.request_id) || {}
 
         # Finish the event in the extension.
         Appsignal::Extension.finish_event(
           transaction.transaction_index,
           'query.mongodb',
-          event.command_name.to_s,
-          %Q(#{event.database_name} | #{result} | #{command})
+          "#{event.command_name.to_s} | #{event.database_name} | #{result}",
+          JSON.generate(command),
+          0
         )
       end
     end

data/lib/appsignal/subscriber.rb

@@ -45,12 +45,13 @@ module Appsignal
       return unless transaction = Appsignal::Transaction.current
       return if transaction.nil_transaction? || transaction.paused?
 
-      title, body = Appsignal::EventFormatter.format(name, payload)
+      title, body, body_format = Appsignal::EventFormatter.format(name, payload)
       Appsignal::Extension.finish_event(
         transaction.transaction_index,
         name,
         title || BLANK,
-        body || BLANK
+        body || BLANK,
+        body_format || 0
       )
     end
   end

data/lib/appsignal/transaction.rb

@@ -124,6 +124,7 @@ module Appsignal
         :params       => sanitized_params,
         :environment  => sanitized_environment,
         :session_data => sanitized_session_data,
+        :metadata     => metadata,
         :tags         => sanitized_tags
       }.each do |key, data|
         set_sample_data(key, data)
@@ -212,6 +213,11 @@ module Appsignal
       Appsignal::ParamsSanitizer.sanitize(session.to_hash)
     end
 
+    def metadata
+      return unless request.env
+      request.env[:metadata]
+    end
+
     # Only keep tags if they meet the following criteria:
     # * Key is a symbol or string with less then 100 chars
     # * Value is a symbol or string with less then 100 chars

data/lib/appsignal/utils.rb

@@ -1,25 +1,36 @@
 module Appsignal
   module Utils
-    def self.sanitize(params, only_top_level=false)
+    def self.sanitize(params, only_top_level=false, key_sanitizer=nil)
       if params.is_a?(Hash)
         {}.tap do |hsh|
           params.each do |key, val|
-            hsh[key] = only_top_level ? '?' : sanitize(val, only_top_level)
+            hsh[self.sanitize_key(key, key_sanitizer)] = if only_top_level
+              '?'
+            else
+              sanitize(val, only_top_level, key_sanitizer=nil)
+            end
           end
         end
       elsif params.is_a?(Array)
         if only_top_level
-          sanitize(params[0], only_top_level)
+          sanitize(params[0], only_top_level, key_sanitizer=nil)
         elsif params.first.is_a?(String)
           ['?']
         else
           params.map do |item|
-            sanitize(item, only_top_level)
+            sanitize(item, only_top_level, key_sanitizer=nil)
           end
         end
       else
         '?'
       end
     end
+
+    def self.sanitize_key(key, sanitizer)
+      case sanitizer
+      when :mongodb then key.gsub(/(\..+)/, '.?')
+      else key
+      end
+    end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require 'yaml'
 
 module Appsignal
-  VERSION = '1.0.4'
+  VERSION = '1.0.5.beta.1'
 end

data/spec/lib/appsignal/capistrano3_spec.rb

@@ -80,9 +80,29 @@ if capistrano3_present?
               )
             end
           end
+
+          context "when stage is used instead of rack_env / rails_env" do
+            before do
+              @capistrano_config.delete(:rails_env)
+              @capistrano_config.set(:stage, 'stage_production')
+            end
+
+            it "should be instantiated with the right params" do
+              Appsignal::Config.should_receive(:new).with(
+                project_fixture_path,
+                'stage_production',
+                {:name => 'AppName'},
+                kind_of(Logger)
+              )
+            end
+          end
         end
 
-        after { invoke('appsignal:deploy') }
+        after do
+          invoke('appsignal:deploy')
+          @capistrano_config.delete(:stage)
+          @capistrano_config.delete(:rack_env)
+        end
       end
 
       context "send marker" do

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 request.net_http" do
+  it "should register instantiation.active_record" 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,195 +1,23 @@
 require 'spec_helper'
 
-if active_record_present?
-  require 'active_record'
+describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
+  let(:klass)     { Appsignal::EventFormatter::ActiveRecord::SqlFormatter }
+  let(:formatter) { klass.new }
 
-  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
-
-        Appsignal::EventFormatter.registered?('sql.active_record').should be_false
-      end
-    end
-
-    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 ?"] }
-
-          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 register sql.active_record" do
+    Appsignal::EventFormatter.registered?('sql.active_record', klass).should be_true
+  end
 
-        it { should be_true }
-      end
+  describe "#format" do
+    let(:payload) do
+      {
+        name: 'User load',
+        sql: 'SELECT * FROM users'
+      }
     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 }
+    subject { formatter.format(payload) }
 
-        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
+    it { should == ['User load', 'SELECT * FROM users', 1] }
   end
 end

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
+  let(:formatter) { Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter }
+
+  describe ".format" do
+    let(:strategy) { :find }
+    let(:command) do
+      {
+        "find"   => "users",
+        "filter" => {"_id" => 1}
+      }
+    end
+
+    it "should apply a strategy for each key" do
+      expect( formatter ).to receive(:apply_strategy)
+        .with(:sanitize_document, {"_id" => 1})
+
+      expect( formatter ).to receive(:apply_strategy)
+        .with(:allow, "users")
+
+      formatter.format(strategy, command)
+    end
+
+    context "when strategy is unkown" do
+      let(:strategy) { :bananas }
+
+      it "should return an empty hash" do
+        expect( formatter.format(strategy, command) ).to eql({})
+      end
+    end
+
+    context "when command is not a hash " do
+      let(:command) { :bananas }
+
+      it "should return an empty hash" do
+        expect( formatter.format(strategy, command) ).to eql({})
+      end
+    end
+  end
+
+  describe ".apply_strategy" do
+    context "when strategy is allow" do
+      let(:strategy) { :allow }
+      let(:value)    { {"_id" => 1} }
+
+      it "should return the given value" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql(value)
+      end
+    end
+
+    context "when strategy is deny" do
+      let(:strategy) { :deny }
+      let(:value)    { {"_id" => 1} }
+
+      it "should return a '?'" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql('?')
+      end
+    end
+
+    context "when strategy is deny_array" do
+      let(:strategy) { :deny_array }
+      let(:value)    { {"_id" => 1} }
+
+      it "should return a sanitized array string" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql("[?]")
+      end
+    end
+
+    context "when strategy is sanitize_document" do
+      let(:strategy) { :sanitize_document }
+      let(:value)    { {"_id" => 1} }
+
+      it "should return a sanitized document" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql({"_id" => '?'})
+      end
+    end
+
+    context "when strategy is sanitize_bulk" do
+      let(:strategy) { :sanitize_bulk }
+      let(:value)    { [{"q" => {"_id" => 1}, "u" => [{"foo" => "bar"}]}] }
+
+      it "should return an array of sanitized bulk documents" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql([
+          {"q" => {"_id" => '?'}, "u" => '[?]'}
+        ])
+      end
+
+      context "when bulk has more than one update" do
+        let(:value) do
+          [
+            {"q" => {"_id" => 1}, "u" => [{"foo" => "bar"}]},
+            {"q" => {"_id" => 2}, "u" => [{"foo" => "baz"}]},
+          ]
+        end
+
+        it "should return only the first value of sanitized bulk documents" do
+          expect( formatter.apply_strategy(strategy, value) ).to eql([
+            {"q" => {"_id" => '?'}, "u" => '[?]'},
+            "[...]"
+          ])
+        end
+      end
+    end
+
+    context "when strategy is missing" do
+      let(:strategy) { nil }
+      let(:value)    { {"_id" => 1} }
+
+      it "should return a '?'" do
+        expect( formatter.apply_strategy(strategy, value) ).to eql('?')
+      end
+    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             => {'_id' => 'abc'},
+          :selector             => {'query' => {'_id' => 'abc'}},
           :class                => double(:to_s => 'Moped::Protocol::Command')
         )
       end
 
-      it { should == ['Command', '{:database=>"database.collection", :selector=>{"_id"=>"?"}}'] }
+      it { should == ['Command', '{:database=>"database.collection", :selector=>{"query"=>"?"}}'] }
     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               => {'name' => 'James Bond'},
+          :update               => {'user.name' => 'James Bond'},
           :flags                => [],
           :class                => double(:to_s => 'Moped::Protocol::Update')
         )
       end
 
-      it { should == ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"name"=>"?"}, :flags=>[]}'] }
+      it { should == ['Update', '{:database=>"database.collection", :selector=>{"_id"=>"?"}, :update=>{"user.?"=>"?"}, :flags=>[]}'] }
     end
 
     context "Moped::Protocol::KillCursors" do

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Appsignal::EventFormatter::Sequel::SqlFormatter do
+  let(:klass)     { Appsignal::EventFormatter::Sequel::SqlFormatter }
+  let(:formatter) { klass.new }
+
+  it "should register sql.sequel" do
+    Appsignal::EventFormatter.registered?('sql.sequel', klass).should be_true
+  end
+
+  describe "#format" do
+    let(:payload) do
+      {
+        sql: 'SELECT * FROM users'
+      }
+    end
+
+    subject { formatter.format(payload) }
+
+    it { should == [nil, 'SELECT * FROM users', 1] }
+  end
+end

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')
+        subject.finish_event(1, 'name', 'title', 'body', 0)
       end
 
       it "should have a set_transaction_error method" 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", "", "")
+        .with(kind_of(Integer), "sql.sequel", "", kind_of(String), 1)
 
       db['SELECT 1'].all
     end

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

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

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', '', '').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
+        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
 
         ActiveSupport::Notifications.instrument('one') do
           ActiveSupport::Notifications.instrument('two') do
@@ -119,7 +119,8 @@ describe Appsignal::Subscriber do
           kind_of(Integer),
           'request.net_http',
           'GET http://www.google.com',
-          ''
+          '',
+          0
         ).once
 
         ActiveSupport::Notifications.instrument(
@@ -130,6 +131,23 @@ 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,6 +331,11 @@ 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',
@@ -616,6 +621,22 @@ 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

@@ -33,4 +33,20 @@ 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
+    end
+  end
 end

data/spec/support/helpers/env_helpers.rb

@@ -15,6 +15,7 @@ module EnvHelpers
       :status => '200',
       :view_runtime => 500,
       :db_runtime => 500,
+      :metadata => {:key => 'value'}
     ).merge(args)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5.beta.1
 platform: ruby
 authors:
 - Robert Beekman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -154,8 +154,10 @@ files:
 - lib/appsignal/event_formatter/action_view/render_formatter.rb
 - lib/appsignal/event_formatter/active_record/instantiation_formatter.rb
 - lib/appsignal/event_formatter/active_record/sql_formatter.rb
+- lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter.rb
 - lib/appsignal/event_formatter/moped/query_formatter.rb
 - lib/appsignal/event_formatter/net_http/request_formatter.rb
+- lib/appsignal/event_formatter/sequel/sql_formatter.rb
 - lib/appsignal/extension.rb
 - lib/appsignal/hooks.rb
 - lib/appsignal/hooks/celluloid.rb
@@ -209,8 +211,10 @@ files:
 - spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb
+- spec/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/net_http/request_formatter_spec.rb
+- spec/lib/appsignal/event_formatter/sequel/sql_formatter_spec.rb
 - spec/lib/appsignal/event_formatter_spec.rb
 - spec/lib/appsignal/extension_spec.rb
 - spec/lib/appsignal/hooks/celluloid_spec.rb
@@ -274,9 +278,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.5
@@ -292,8 +296,10 @@ test_files:
 - spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb
+- spec/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb
 - spec/lib/appsignal/event_formatter/net_http/request_formatter_spec.rb
+- spec/lib/appsignal/event_formatter/sequel/sql_formatter_spec.rb
 - spec/lib/appsignal/event_formatter_spec.rb
 - spec/lib/appsignal/extension_spec.rb
 - spec/lib/appsignal/hooks/celluloid_spec.rb