appsignal 0.10.6 → 0.11.0.beta.1

data/lib/appsignal/transaction.rb

@@ -1,4 +1,4 @@
- module Appsignal
+module Appsignal
   class Transaction
     # Based on what Rails uses + some variables we'd like to show
     ENV_METHODS = %w(CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
@@ -97,9 +97,13 @@
       process_action_event.duration > transaction.process_action_event.duration
     end
 
+    def clear_events!
+      events.clear
+    end
+
     def truncate!
       return if truncated?
-      process_action_event.payload.clear
+      process_action_event.truncate!
       events.clear
       tags.clear
       sanitized_environment.clear
@@ -114,12 +118,8 @@
 
     def convert_values_to_primitives!
       return if have_values_been_converted_to_primitives?
-      Appsignal::Transaction::ParamsSanitizer.sanitize!(@process_action_event.payload) if @process_action_event
-      @events.map do |o|
-        o.payload.each do |key, value|
-          o.payload[key] = Appsignal::Transaction::ParamsSanitizer.sanitize(value)
-        end
-      end
+      @process_action_event.sanitize! if @process_action_event
+      @events.each { |event| event.sanitize! }
       add_sanitized_context!
       @have_values_been_converted_to_primitives = true
     end
@@ -142,10 +142,9 @@
       Thread.current[:appsignal_transaction_id] = nil
       Appsignal.transactions.delete(@request_id)
       if process_action_event || exception?
-        if Appsignal::Pipe.current
+        if Appsignal::IPC::Client.active?
           convert_values_to_primitives!
-          Appsignal.logger.debug("Writing transaction to pipe: #{@request_id}")
-          Appsignal::Pipe.current.write(self)
+          Appsignal::IPC::Client.enqueue(self)
         else
           Appsignal.logger.debug("Enqueueing transaction: #{@request_id}")
           Appsignal.enqueue(self)
@@ -204,7 +203,7 @@
     end
 
     def sanitize_session_data!
-      @sanitized_session_data = Appsignal::Transaction::ParamsSanitizer.sanitize(
+      @sanitized_session_data = Appsignal::ParamsSanitizer.sanitize(
         request.session.to_hash
       ) if Appsignal.config[:skip_session_data] == false
       @fullpath = request.fullpath

data/lib/appsignal/transaction/params_sanitizer.rb

@@ -1,119 +1,4 @@
-module Appsignal
-  class Transaction
-    class ParamsSanitizer
-      class << self
-        def sanitize(params)
-          ParamsSanitizerCopy.sanitize_value(params)
-        end
+# The Appsignal-moped gem depends on this class
+class Appsignal::Transaction::ParamsSanitizer < Appsignal::ParamsSanitizer
 
-        def sanitize!(params)
-          ParamsSanitizerDestructive.sanitize_value(params)
-        end
-
-        def scrub(params)
-          ParamsSanitizerCopyScrub.sanitize_value(params)
-        end
-
-        def scrub!(params)
-          ParamsSanitizerDestructiveScrub.sanitize_value(params)
-        end
-
-        protected
-
-        def sanitize_value(value)
-          case value
-          when Hash
-            sanitize_hash(value)
-          when Array
-            sanitize_array(value)
-          when Fixnum, String, Symbol
-            unmodified(value)
-          else
-            inspected(value)
-          end
-        end
-
-        def sanitize_hash_with_target(source_hash, target_hash)
-          source_hash.each_pair do |key, value|
-            target_hash[key] = sanitize_value(value)
-          end
-          target_hash
-        end
-
-        def sanitize_array_with_target(source_array, target_array)
-          source_array.each_with_index do |item, index|
-            target_array[index] = sanitize_value(item)
-          end
-          target_array
-        end
-
-        def unmodified(value)
-          value
-        end
-
-        def inspected(value)
-          value.inspect
-        rescue
-          # It turns out that sometimes inspect can fail
-          "#<#{value.class.to_s}/>"
-        end
-      end
-    end
-
-    class ParamsSanitizerCopy < ParamsSanitizer
-      class << self
-        protected
-
-        def sanitize_hash(hash)
-          sanitize_hash_with_target(hash, {})
-        end
-
-        def sanitize_array(array)
-          sanitize_array_with_target(array, [])
-        end
-      end
-    end
-
-    class ParamsSanitizerDestructive < ParamsSanitizer
-      class << self
-        protected
-
-        def sanitize_hash(hash)
-          sanitize_hash_with_target(hash, hash)
-        end
-
-        def sanitize_array(array)
-          sanitize_array_with_target(array, array)
-        end
-      end
-    end
-
-    class ParamsSanitizerCopyScrub < ParamsSanitizerCopy
-      class << self
-        protected
-
-        def unmodified(value)
-          '?'
-        end
-
-        def inspected(value)
-          '?'
-        end
-      end
-    end
-
-    class ParamsSanitizerDestructiveScrub < ParamsSanitizerDestructive
-      class << self
-        protected
-
-        def unmodified(value)
-          '?'
-        end
-
-        def inspected(value)
-          '?'
-        end
-      end
-    end
-  end
 end

data/lib/appsignal/transmitter.rb

@@ -10,6 +10,17 @@ module Appsignal
     CONTENT_ENCODING = 'gzip'.freeze
     CA_FILE_PATH = File.expand_path(File.join(__FILE__, '../../../resources/cacert.pem'))
 
+    HTTP_ERRORS = [
+      EOFError,
+      Errno::ECONNRESET,
+      Errno::EINVAL,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      Timeout::Error,
+      OpenSSL::SSL::SSLError
+    ]
+
     attr_reader :config, :action
 
     def initialize(action, config=Appsignal.config)

data/lib/appsignal/version.rb

@@ -1,3 +1,3 @@
 module Appsignal
-  VERSION = '0.10.6'
+  VERSION = '0.11.0.beta.1'
 end

data/spec/lib/appsignal/agent_spec.rb

@@ -32,7 +32,16 @@ describe Appsignal::Agent do
   end
 
   describe "#start_thread" do
-    before { subject.thread = nil }
+    before do
+      subject.thread = nil
+      subject.stub(:sleep_time => 0.1)
+    end
+
+    it "should truncate the aggregator queue" do
+      subject.should_receive(:truncate_aggregator_queue).at_least(1).times
+      subject.start_thread
+      sleep 1
+    end
 
     context "without transactions" do
       it "should start and run a background thread" do
@@ -47,10 +56,7 @@ describe Appsignal::Agent do
 
     context "with transactions" do
       before do
-        subject.stub(
-          :aggregator => double(:has_transactions? => true),
-          :sleep_time => 0.01
-        )
+        subject.stub(:aggregator => double(:has_transactions? => true))
       end
 
       it "should send the queue and sleep" do
@@ -67,10 +73,7 @@ describe Appsignal::Agent do
         aggregator.stub(:has_transactions?).and_raise(
           RuntimeError.new('error')
         )
-        subject.stub(
-          :aggregator => aggregator,
-          :sleep_time => 0.1
-        )
+        subject.stub(:aggregator => aggregator)
       end
 
       it "should log the error" do
@@ -250,20 +253,51 @@ describe Appsignal::Agent do
   end
 
   describe "#send_queue" do
-    context "without transactions" do
-      it "does not transmit" do
-        subject.should_not_receive(:handle_result)
-      end
+    it "adds aggregator to queue" do
+      subject.aggregator.stub(:post_processed_queue! => :foo)
+      subject.should_receive(:add_to_aggregator_queue).with(:foo)
     end
 
-    context "with transactions" do
-      before do
-        subject.aggregator.stub(:has_transactions? => true)
-      end
+    it "sends aggregators" do
+      subject.should_receive(:send_aggregators)
+    end
+
+    it "handle exceptions in post processing" do
+      subject.aggregator.stub(:post_processed_queue!).and_raise(
+        PostProcessingException.new('Message')
+      )
+
+      Appsignal.logger.should_receive(:error).
+        with('PostProcessingException while sending queue: Message').
+        once
+      Appsignal.logger.should_receive(:error).
+        with(kind_of(String)).
+        once
+    end
 
-      it "transmits" do
-        subject.aggregator.stub(:post_processed_queue! => :foo)
-        subject.transmitter.should_receive(:transmit).with(:foo)
+    it "handles exceptions in transmit" do
+      subject.stub(:send_aggregators).and_raise(
+        Exception.new('Message')
+      )
+
+      Appsignal.logger.should_receive(:error).
+        with('Exception while sending queue: Message').
+        once
+      Appsignal.logger.should_receive(:error).
+        with(kind_of(String)).
+        once
+    end
+
+    after { subject.send_queue }
+  end
+
+  describe "#send_aggregators" do
+    let(:aggregator_hash) { double }
+    before { subject.add_to_aggregator_queue(aggregator_hash) }
+
+    context "sending aggreagotor hashes" do
+      it "sends each item in the aggregators_to_be_sent array" do
+        subject.transmitter.should_receive(:transmit).with(aggregator_hash)
       end
 
       it "handles the return code" do
@@ -271,43 +305,63 @@ describe Appsignal::Agent do
         subject.should_receive(:handle_result).with('200')
       end
 
-      it "handle exceptions in post processing" do
-        subject.aggregator.stub(:post_processed_queue!).and_raise(
-          PostProcessingException.new('Message')
-        )
+      after { subject.send_aggregators }
+    end
 
-        Appsignal.logger.should_receive(:error).
-          with('PostProcessingException while sending queue: Message').
-          once
-        Appsignal.logger.should_receive(:error).
-          with(kind_of(String)).
-          once
+    context "managing the queue" do
+      before { subject.transmitter.stub(:transmit => '200') }
+
+      context "when successfully sent" do
+        before { subject.stub(:handle_result => true) }
+
+        it "should remove only successfully sent item from the queue" do
+          expect {
+            subject.send_aggregators
+          }.to change(subject, :aggregator_queue).from([aggregator_hash]).to([])
+        end
       end
 
-      it "handles exceptions in transmit" do
-        subject.transmitter.stub(:transmit).and_raise(
-          Exception.new('Message')
-        )
+      context "when failed to sent" do
+        before { subject.stub(:handle_result => false) }
 
-        Appsignal.logger.should_receive(:error).
-          with('Exception while sending queue: Message').
-          once
-        Appsignal.logger.should_receive(:error).
-          with(kind_of(String)).
-          once
+        it "should remove only successfully sent item from the queue" do
+          expect {
+            subject.send_aggregators
+          }.to_not change(subject, :aggregator_queue)
+        end
       end
 
-      it "handles an OpenSSL error in transmit" do
-        subject.transmitter.stub(:transmit).and_raise(
-          OpenSSL::SSL::SSLError.new('Message')
-        )
+      context "when an exception occurred during sending" do
+        before { subject.stub(:transmitter).and_raise(OpenSSL::SSL::SSLError.new) }
+
+        it "should remove only successfully sent item from the queue" do
+          expect {
+            subject.send_aggregators
+          }.to_not change(subject, :aggregator_queue)
+        end
 
-        Appsignal.logger.should_receive(:error).
-          with('OpenSSL::SSL::SSLError: Message').once
       end
     end
+  end
 
-    after { subject.send_queue }
+  describe "#truncate_aggregator_queue" do
+    before do
+      5.times { |i| subject.add_to_aggregator_queue(i) }
+    end
+
+    it "should truncate the queue to the given limit" do
+      expect {
+        subject.truncate_aggregator_queue(2)
+      }.to change(subject, :aggregator_queue).from([4, 3, 2, 1, 0]).to([4,3])
+    end
+
+    it "should log this event as an error" do
+      Appsignal.logger.should_receive(:error).
+        with('Aggregator queue to large, removing items').
+        once
+
+      subject.truncate_aggregator_queue(2)
+    end
   end
 
   describe "#clear_queue" do
@@ -441,13 +495,23 @@ describe Appsignal::Agent do
         it "logs the event" do
           Appsignal.logger.should_receive(:error)
         end
+      end
 
-        it "clears the queue" do
-          subject.should_receive(:clear_queue)
+      after { subject.send(:handle_result, code) }
+    end
+
+    context "return values" do
+      %w( 200 420 413 429 406 402 401 ).each do |code|
+        it "should return true for '#{code}'" do
+          subject.send(:handle_result, code).should be_true
         end
       end
 
-      after { subject.send(:handle_result, code) }
+      %w( 500 502 ).each do |code|
+        it "should return false for '#{code}'" do
+          subject.send(:handle_result, code).should be_false
+        end
+      end
     end
   end
 

data/spec/lib/appsignal/aggregator_spec.rb

@@ -27,6 +27,7 @@ describe Appsignal::Aggregator do
     context "adding a transaction with an exception" do
       let(:transaction) { transaction_with_exception }
 
+      specify { transaction.should_receive(:clear_events!) }
       specify { transaction.should_receive(:convert_values_to_primitives!) }
     end
 

data/spec/lib/appsignal/event/moped_event_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe Appsignal::Event::MopedEvent do
+  let(:event) do
+    Appsignal::Event::MopedEvent.new('query.moped', 1, 2, 123, {})
+  end
+
+  describe "#transform_payload" do
+    before { event.stub(:payload_from_op => {'foo' => 'bar'}) }
+
+    it "should map the operations to a normalized payload" do
+      expect( event.transform_payload(:ops => [{}]) ).to eq(
+        :ops => [{'foo' => 'bar'}]
+      )
+    end
+  end
+
+  describe "#payload_from_op" do
+    context "Moped::Protocol::Query" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :selector             => {'_id' => 'abc'},
+          :class                => double(:to_s => 'Moped::Protocol::Command')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "Command",
+          :database => "database.collection",
+          :selector => {"_id" => "?"}
+        )
+      end
+    end
+
+    context "Moped::Protocol::Query" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :selector             => {'_id' => 'abc'},
+          :flags                => [],
+          :limit                => 0,
+          :skip                 => 0,
+          :fields               => nil,
+          :class                => double(:to_s => 'Moped::Protocol::Query')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "Query",
+          :database => "database.collection",
+          :selector => {"_id" => "?"},
+          :flags    => [],
+          :limit    => 0,
+          :skip     => 0,
+          :fields   => nil,
+        )
+      end
+    end
+
+    context "Moped::Protocol::Delete" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :selector             => {'_id' => 'abc'},
+          :flags                => [],
+          :class                => double(:to_s => 'Moped::Protocol::Delete')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "Delete",
+          :database => "database.collection",
+          :selector => {"_id" => "?"},
+          :flags    => []
+        )
+      end
+    end
+
+    context "Moped::Protocol::Insert" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :flags                => [],
+          :documents            => [{'_id' => 'abc'}, {'_id' => 'def'}],
+          :class                => double(:to_s => 'Moped::Protocol::Insert')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type      => "Insert",
+          :database  => "database.collection",
+          :flags     => [],
+          :documents => [{"_id" => "?"}, {"_id" => "?"}]
+        )
+      end
+    end
+
+    context "Moped::Protocol::Update" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :selector             => {'_id' => 'abc'},
+          :update               => {'name' => 'James Bond'},
+          :flags                => [],
+          :class                => double(:to_s => 'Moped::Protocol::Update')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "Update",
+          :database => "database.collection",
+          :selector => {"_id" => "?"},
+          :update   => {"name" => "?"},
+          :flags    => []
+        )
+      end
+    end
+
+    context "Moped::Protocol::Other" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :class                => double(:to_s => 'Moped::Protocol::Other')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "Other",
+          :database => "database.collection"
+        )
+      end
+    end
+
+    context "Moped::Protocol::KillCursors" do
+      let(:payload) do
+        double(
+          :full_collection_name => 'database.collection',
+          :class                => double(:to_s => 'Moped::Protocol::KillCursors')
+        )
+      end
+
+      it "should transform the payload" do
+        expect( event.payload_from_op(payload) ).to eq(
+          :type     => "KillCursors",
+          :database => "database.collection"
+        )
+      end
+    end
+  end
+
+  describe "#sanitize" do
+    context "when params is a hash" do
+      let(:params) { {'foo' => 'bar'} }
+
+      it "should sanitize all hash values with a questionmark" do
+        expect( event.sanitize(params) ).to eq('foo' => '?')
+      end
+    end
+
+    context "when params is an array of hashes" do
+      let(:params) { [{'foo' => 'bar'}] }
+
+      it "should sanitize all hash values with a questionmark" do
+        expect( event.sanitize(params) ).to eq([{'foo' => '?'}])
+      end
+    end
+
+    context "when params is an array of strings " do
+      let(:params) { ['foo', 'bar'] }
+
+      it "should sanitize all hash values with a single questionmark" do
+        expect( event.sanitize(params) ).to eq(['?'])
+      end
+    end
+    context "when params is a string" do
+      let(:params) { 'bar'}
+
+      it "should sanitize all hash values with a questionmark" do
+        expect( event.sanitize(params) ).to eq('?')
+      end
+    end
+  end
+end