appsignal 0.4.7 → 0.5.0

data/lib/appsignal/transaction/transaction_formatter.rb

@@ -1,95 +1,59 @@
 require 'forwardable'
 
 module Appsignal
-  class TransactionFormatter
-    extend Forwardable
+  class TransactionFormatter < SimpleDelegator
 
     def initialize(transaction)
-      @transaction = transaction
+      super(transaction)
     end
 
-    def self.regular(transaction)
-      TransactionFormatter::RegularRequestFormatter.new(transaction)
+    def hash
+      @hash ||= default_hash
     end
 
-    def self.slow(transaction)
-      TransactionFormatter::SlowRequestFormatter.new(transaction)
+    def to_hash
+      merge_process_action_event_with_log_entry! if process_action_event
+      add_exception_to_hash! if exception?
+      add_events_to_hash! if slow_request?
+      hash
     end
 
-    def self.faulty(transaction)
-      TransactionFormatter::FaultyRequestFormatter.new(transaction)
-    end
+    protected
 
-    def to_hash
+    def default_hash
       {
         :request_id => id,
-        :action => action,
-        :log_entry => formatted_process_action_event,
+        :log_entry => {
+          :path => fullpath,
+          :kind => 'http_request',
+          :time => time,
+          :environment => sanitized_environment,
+          :session_data => sanitized_session_data
+        },
         :failed => exception?
       }
     end
 
-    protected
-
-    def_delegators :transaction, :id, :events, :exception, :exception?, :env,
-      :request, :process_action_event, :action
-    def_delegators :process_action_event, :payload
-
-    attr_reader :transaction
-
-    def formatted_process_action_event
-      basic_process_action_event.tap { |hsh| hsh.merge!(formatted_payload) if process_action_event }
+    def merge_process_action_event_with_log_entry!
+      hash[:log_entry].merge!(process_action_event.to_appsignal_hash)
+      hash[:log_entry].tap do |o|
+        o.merge!(o.delete(:payload))
+        o[:action] = "#{o.delete(:controller)}##{o.delete(:action)}"
+        o.delete(:name)
+      end
     end
 
-    def basic_process_action_event
-      {
-        :path => request.fullpath,
-        :kind => 'http_request'
+    def add_exception_to_hash!
+      hash[:exception] = {
+        :backtrace => exception.backtrace,
+        :exception => exception.name,
+        :message => exception.message
       }
     end
 
-    def formatted_payload
-      sanitized_event_payload(process_action_event).merge(
-        {
-          :duration => process_action_event.duration,
-          :time => process_action_event.time.to_f,
-          :end => process_action_event.end.to_f,
-          :action => action
-        }
-      )
-    end
-
-    def sanitized_event_payload(event)
-      Appsignal::ParamsSanitizer.sanitize(
-        Appsignal.event_payload_sanitizer.call(event)
-      )
+    def add_events_to_hash!
+      hash[:events] = events.map(&:to_appsignal_hash)
     end
 
-    def filtered_environment
-      {}.tap do |out|
-        env.each_pair do |key, value|
-          out[key] = value if ENV_METHODS.include?(key)
-        end
-      end
-    end
-
-    # Based on what Rails uses + some variables we'd like to show
-    ENV_METHODS = %w{ CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
-    PATH_TRANSLATED REMOTE_HOST REMOTE_IDENT REMOTE_USER
-    REMOTE_ADDR REQUEST_METHOD SERVER_NAME SERVER_PORT
-    SERVER_PROTOCOL
-
-    HTTP_X_REQUEST_START HTTP_X_MIDDLEWARE_START HTTP_X_QUEUE_START
-    HTTP_X_QUEUE_TIME HTTP_X_HEROKU_QUEUE_WAIT_TIME
-    HTTP_X_APPLICATION_START HTTP_ACCEPT HTTP_ACCEPT_CHARSET
-    HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL
-    HTTP_CONNECTION HTTP_USER_AGENT HTTP_FROM HTTP_NEGOTIATE
-    HTTP_PRAGMA HTTP_REFERER }.freeze
-
   end
 end
-
-require 'appsignal/transaction/regular_request_formatter'
-require 'appsignal/transaction/slow_request_formatter'
-require 'appsignal/transaction/faulty_request_formatter'
-require 'appsignal/transaction/params_sanitizer'

data/lib/appsignal/version.rb

@@ -1,3 +1,3 @@
 module Appsignal
-  VERSION = '0.4.7'
+  VERSION = '0.5.0'
 end

data/spec/appsignal/agent_spec.rb

@@ -1,119 +1,24 @@
 require 'spec_helper'
 
-describe Appsignal::Agent do
-  let(:transaction) { stub(
-    :name => 'transaction',
-    :exception? => false,
-    :action => 'something#else'
-  ) }
-
-  describe '#add_to_queue' do
-    before do
-      @agent = Appsignal::Agent.new
-      @exception_transaction = stub(
-        :name => 'exception',
-        :exception? => true,
-        :action => 'controller#action1'
-      )
-      @slow_transaction = stub(
-        :name => 'slow',
-        :action => 'controller#action1',
-        :exception? => false,
-        :process_action_event => stub(
-          :duration => 250.0
-        )
-      )
-      @slower_transaction = stub(
-        :name => 'slow',
-        :action => 'controller#action1',
-        :exception? => false,
-        :process_action_event => stub(
-          :duration => 300.0
-        )
-      )
-      @other_slow_transaction = stub(
-        :name => 'slow',
-        :action => 'controller#action1',
-        :exception? => false,
-        :process_action_event => stub(
-          :duration => 260.0
-        )
-      )
-      @slow_transaction_in_other_action = stub(
-        :name => 'slow',
-        :action => 'controller#action2',
-        :exception? => false,
-        :process_action_event => stub(
-          :duration => 400.0
-        )
-      )
-    end
-    subject { @agent }
-
-    context "an exception transaction" do
-      before do
-        @exception_transaction.should_not_receive(:clear_payload_and_events!)
-        subject.add_to_queue(@exception_transaction)
-      end
-
-      its(:queue) { should include(@exception_transaction) }
-      its(:slowest_transactions) { should be_empty }
+class PostProcessingException < Exception
+end
 
-      context "a slow transaction" do
-        before do
-          subject.add_to_queue(@slow_transaction)
-        end
+describe Appsignal::Agent do
+  let(:transaction) { regular_transaction }
 
-        its(:queue) { should include(@slow_transaction) }
-        its(:slowest_transactions) { should == {
-          'controller#action1' => @slow_transaction
-        } }
-
-        context "a slower transaction in the same action" do
-          before do
-            @slow_transaction.should_receive(:clear_payload_and_events!)
-            @slower_transaction.should_not_receive(:clear_payload_and_events!)
-            subject.add_to_queue(@slower_transaction)
-          end
-
-          its(:queue) { should include(@slower_transaction) }
-          its(:slowest_transactions) { should == {
-            'controller#action1' => @slower_transaction
-          } }
-
-          context "a slow but not the slowest transaction in the same action" do
-            before do
-              @other_slow_transaction.should_receive(:clear_payload_and_events!)
-              subject.add_to_queue(@other_slow_transaction)
-            end
-
-            its(:queue) { should include(@other_slow_transaction) }
-            its(:slowest_transactions) { should == {
-              'controller#action1' => @slower_transaction
-            } }
-          end
-
-          context "an even slower transaction in a different action" do
-            before do
-              @slow_transaction_in_other_action.should_not_receive(:clear_payload_and_events!)
-              subject.add_to_queue(@slow_transaction_in_other_action)
-            end
-
-            its(:queue) { should include(@slow_transaction_in_other_action) }
-            its(:slowest_transactions) { should == {
-              'controller#action1' => @slower_transaction,
-              'controller#action2' => @slow_transaction_in_other_action
-            } }
-          end
-        end
-      end
+  describe "#enqueue" do
+    it "forwards to the aggregator" do
+      subject.aggregator.should respond_to(:add)
+      subject.aggregator.should_receive(:add).with(:foo)
     end
+
+    after { subject.enqueue(:foo) }
   end
 
   describe "#send_queue" do
     it "transmits" do
-      subject.stub(:queue => [stub(:to_hash => 'foo')])
-      subject.transmitter.should_receive(:transmit).with(['foo'])
+      subject.aggregator.stub(:post_processed_queue! => :foo)
+      subject.transmitter.should_receive(:transmit).with(:foo)
     end
 
     it "handles the return code" do
@@ -121,42 +26,62 @@ 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')
+      )
+
+      subject.should_receive(:stop_logging)
+      Appsignal.logger.should_receive(:error).
+        with('PostProcessingException while sending queue: Message').
+        once
+      Appsignal.logger.should_receive(:error).
+        with(kind_of(String)).
+        once
+    end
+
     it "handles exceptions in transmit" do
-      subject.transmitter.stub(:transmit).and_raise(Exception.new)
-      subject.should_receive(:handle_result).with(nil)
-      Appsignal.logger.should_receive(:error).with('Exception while communicating with AppSignal: Exception')
+      subject.transmitter.stub(:transmit).and_raise(
+        Exception.new('Message')
+      )
+      subject.should_receive(:stop_logging)
+      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 '#handle_result' do
-    before { subject.add_to_queue(transaction) }
+    before { subject.aggregator.add(transaction) }
     before { subject.instance_variable_set(:@sleep_time, 3.0) }
 
     context "good responses" do
-      before { subject.handle_result(code) }
+      before { subject.send(:handle_result, code) }
 
       context "with 200" do
         let(:code) { '200' }
 
-        its(:queue) { should be_empty }
-        its(:slowest_transactions) { should be_empty }
+        its(:sleep_time) { should == 3.0 }
+
+        it "does not log the event" do
+          Appsignal.logger.should_not_receive(:error)
+        end
       end
 
       context "with 420" do
         let(:code) { '420' }
 
-        its(:queue) { should be_empty }
-        its(:slowest_transactions) { should be_empty }
         its(:sleep_time) { should == 4.5 }
       end
 
       context "with 413" do
         let(:code) { '413' }
 
-        its(:queue) { should be_empty }
-        its(:slowest_transactions) { should be_empty }
         its(:sleep_time) { should == 2.0 }
       end
     end
@@ -197,47 +122,12 @@ describe Appsignal::Agent do
       context "any other response" do
         let(:code) { 'any other response' }
 
-        it "calls retry_once" do
-          subject.should_receive :retry_once
+        it "logs the event" do
+          Appsignal.logger.should_receive(:error)
         end
       end
 
-      after { subject.handle_result(code) }
-    end
-  end
-
-  describe "#good_response" do
-    before do
-      subject.instance_variable_set(:@retry_once, false)
-      subject.add_to_queue(transaction)
-      subject.send :good_response
-    end
-
-    its(:queue) { should be_empty }
-    its(:slowest_transactions) { should be_empty }
-
-    it "allows the next request to be retried" do
-      subject.instance_variable_get(:@retry_request).should be_true
-    end
-  end
-
-  describe "#retry_once" do
-    before do
-      subject.add_to_queue(transaction)
-      subject.send :retry_once
-    end
-
-    context "on time," do
-      its(:queue) { should == [transaction] }
-      its(:slowest_transactions) { should == {
-        'something#else' => transaction
-      } }
-
-      context "two times" do
-        before { subject.send :retry_once }
-
-        its(:queue) { should be_empty }
-      end
+      after { subject.send(:handle_result, code) }
     end
   end
 

data/spec/appsignal/aggregator/post_processor_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Appsignal::PostProcessor do
+  let(:klass) { Appsignal::PostProcessor }
+  let(:post_processor) { klass.new(transactions) }
+
+  describe "#initialize" do
+    subject { klass.new(:foo) }
+
+    its(:transactions) { should == :foo }
+  end
+
+  describe "#post_processed_queue!" do
+    let(:first_transaction) { regular_transaction }
+    let(:second_transaction) do
+      slow_transaction(
+        :events => [
+          notification_event(
+            :payload => {
+              :set_value => 'set value',
+              :nil_value => nil
+            }
+          )
+        ]
+      )
+    end
+    let(:transactions) { [first_transaction, second_transaction] }
+    let(:processed_queue) { post_processor.post_processed_queue! }
+    subject { processed_queue }
+
+    it { should have(2).items }
+
+    context "the first transaction" do
+      subject { processed_queue[0] }
+
+      it { should_not have_key(:events) }
+
+      context "log entry" do
+        subject { processed_queue[0][:log_entry] }
+
+        it { should have_key(:duration) }
+        it { should have_key(:end) }
+        it { should_not have_key(:events) }
+      end
+    end
+
+    context "the second transaction" do
+      context "log entry" do
+        subject { processed_queue[1][:log_entry] }
+
+        it { should have_key(:duration) }
+        it { should have_key(:end) }
+      end
+
+      context "first event" do
+        subject { processed_queue[1][:events][0] }
+
+        it { should_not be_nil }
+        it { should have_key(:name) }
+
+        it "should have the set value in the payload" do
+          subject[:payload][:set_value].should == 'set value'
+        end
+
+        it "should not have the nil value in the payload"\
+           "since delete blanks is in the middle ware stack" do
+          subject[:payload].should_not have_key(:nil_value)
+        end
+      end
+    end
+  end
+
+  describe ".default_middleware" do
+    subject { klass.default_middleware }
+
+    it { should be_instance_of Appsignal::Middleware::Chain }
+
+    it "should include the default middleware stack" do
+      subject.exists?(Appsignal::Middleware::DeleteBlanks).should be_true
+      subject.exists?(Appsignal::Middleware::ActionViewSanitizer).should be_true
+      subject.exists?(Appsignal::Middleware::ActiveRecordSanitizer).should be_true
+    end
+  end
+end