appsignal 1.1.0.beta.6 → 1.1.0.beta.7

data/lib/appsignal/js_exception_transaction.rb

@@ -28,7 +28,7 @@ module Appsignal
         @transaction_index,
         @data['name'],
         @data['message'],
-        JSON.generate(@data['backtrace'])
+        Appsignal::Utils.json_generate(@data['backtrace'])
       )
     end
 
@@ -43,7 +43,7 @@ module Appsignal
           Appsignal::Extension.set_transaction_sample_data(
             @transaction_index,
             key.to_s,
-            JSON.generate(data)
+            Appsignal::Utils.json_generate(data)
           )
         rescue JSON::GeneratorError=>e
           Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")

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

@@ -113,7 +113,7 @@ module Appsignal
       Appsignal::Extension.set_transaction_sample_data(
         transaction_index,
         key.to_s,
-        JSON.generate(data)
+        Appsignal::Utils.json_generate(data)
       )
     rescue JSON::GeneratorError=>e
       Appsignal.logger.error("JSON generate error (#{e.message}) for '#{data.inspect}'")
@@ -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)
@@ -141,7 +142,7 @@ module Appsignal
         transaction_index,
         error.class.name,
         error.message,
-        backtrace ? JSON.generate(backtrace) : ''
+        backtrace ? Appsignal::Utils.json_generate(backtrace) : ''
       )
     rescue JSON::GeneratorError=>e
       Appsignal.logger.error("JSON generate error (#{e.message}) for '#{backtrace.inspect}'")
@@ -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/transmitter.rb

@@ -53,7 +53,7 @@ module Appsignal
         request['Content-Type'] = CONTENT_TYPE
         request['Content-Encoding'] = CONTENT_ENCODING
         request.body = Zlib::Deflate.deflate(
-          JSON.generate(payload, :quirks_mode => true),
+          Appsignal::Utils.json_generate(payload),
           Zlib::BEST_SPEED
         )
       end

data/lib/appsignal/utils.rb

@@ -1,25 +1,59 @@
 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.to_s.gsub(/(\..+)/, '.?')
+      else key
+      end
+    end
+
+    def self.json_generate(body)
+      JSON.generate(jsonify(body))
+    end
+
+    def self.jsonify(value)
+      case value
+      when String
+        value.encode(
+          'utf-8',
+          :invalid => :replace,
+          :undef   => :replace
+        )
+      when Numeric, NilClass, TrueClass, FalseClass
+        value
+      when Hash
+        Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
+      when Array
+        value.map { |v| jsonify(v) }
+      else
+        jsonify(value.to_s)
+      end
+    end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require 'yaml'
 
 module Appsignal
-  VERSION = '1.1.0.beta.6'
+  VERSION = '1.1.0.beta.7'
 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/config_spec.rb

@@ -98,6 +98,18 @@ describe Appsignal::Config do
         ENV['APPSIGNAL_HTTP_PROXY'].should                   == 'http://localhost'
         ENV['APPSIGNAL_IGNORE_ACTIONS'].should               == 'action1,action2'
         ENV['APPSIGNAL_RUNNING_IN_CONTAINER'].should         == 'false'
+        ENV['APPSIGNAL_WORKING_DIR_PATH'].should             be_nil
+      end
+
+      context "if working_dir_path is set" do
+        before do
+          subject.config_hash[:working_dir_path] = '/tmp/appsignal2'
+          subject.write_to_environment
+        end
+
+        it "should write the current config to env vars" do
+          ENV['APPSIGNAL_WORKING_DIR_PATH'].should == '/tmp/appsignal2'
+        end
       end
     end
 

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