appsignal 0.4.7 → 0.5.0

data/spec/appsignal/middleware/delete_blanks_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Appsignal::Middleware::DeleteBlanks do
+  let(:klass) { Appsignal::Middleware::DeleteBlanks }
+  let(:delete_blanks) { klass.new }
+
+  describe "#call" do
+    let(:event) do
+      notification_event(
+        :name => 'something',
+        :payload => create_payload(payload)
+      )
+    end
+    let(:payload) do
+      {
+        :string => 'not empty',
+        :array => ['something'],
+        :hash => {'something' => 'something'},
+        :empty_string => '',
+        :empty_array => [],
+        :empty_hash => {},
+        :nil => nil
+      }
+    end
+    subject { event.payload }
+    before { delete_blanks.call(event) { } }
+
+    it { should have_key(:string) }
+    it { should have_key(:array) }
+    it { should have_key(:hash) }
+
+    it { should_not have_key(:empty_string) }
+    it { should_not have_key(:empty_array) }
+    it { should_not have_key(:empty_hash) }
+    it { should_not have_key(:nil) }
+  end
+end

data/spec/appsignal/railtie_spec.rb

@@ -3,52 +3,65 @@ require 'action_controller/railtie'
 require 'appsignal/railtie'
 
 describe Appsignal::Railtie do
-
-  before(:all) { MyApp::Application.initialize! }
-
-  it "should have set the appsignal subscriber" do
-    Appsignal.subscriber.
-      should be_a ActiveSupport::Notifications::Fanout::Subscriber
+  it "should log to the in memory log before init" do
+    Appsignal.logger.error('Log something before init')
+    Appsignal.in_memory_log.string.should include('Log something before init')
   end
 
-  it "should have added the middleware for exceptions" do
-    MyApp::Application.middleware.to_a.should include Appsignal::Middleware
-  end
+  context "after initializing the app" do
+    before(:all) { MyApp::Application.initialize! }
 
-  context "non action_controller event" do
-    it "should call add_event for non action_controller event" do
-      current = stub
-      current.should_receive(:add_event)
-      Appsignal::Transaction.should_receive(:current).twice.
-        and_return(current)
+    it "should start logging to file and have written the in memory log" do
+      Appsignal.logger.should be_instance_of(Logger)
+      File.open(log_file).read.should include(
+        'Log something before init'
+      )
     end
 
-    after { ActiveSupport::Notifications.instrument 'query.mongoid' }
-  end
+    it "should have set the appsignal subscriber" do
+      Appsignal.subscriber.
+        should be_a ActiveSupport::Notifications::Fanout::Subscriber
+    end
 
-  context "action_controller event" do
-    it "should call set_process_action_event for action_controller event" do
-      current = stub
-      current.should_receive(:set_process_action_event)
-      current.should_receive(:add_event)
-      Appsignal::Transaction.should_receive(:current).exactly(3).times.
-        and_return(current)
+    it "should have added the listener middleware for exceptions" do
+      MyApp::Application.middleware.to_a.should include Appsignal::Listener
     end
 
-    after do
-      ActiveSupport::Notifications.
-        instrument 'process_action.action_controller'
+    context "non action_controller event" do
+      it "should call add_event for non action_controller event" do
+        current = mock(:current)
+        current.should_receive(:add_event)
+        Appsignal::Transaction.should_receive(:current).twice.
+          and_return(current)
+      end
+
+      after { ActiveSupport::Notifications.instrument 'query.mongoid' }
     end
-  end
 
-  context "event that starts with a bang" do
-    it "should not be processed" do
-      Appsignal::Transaction.should_not_receive(:current)
+    context "action_controller event" do
+      it "should call set_process_action_event for action_controller event" do
+        current = mock(:current)
+        current.should_receive(:set_process_action_event)
+        current.should_receive(:add_event)
+        Appsignal::Transaction.should_receive(:current).exactly(3).times.
+          and_return(current)
+      end
+
+      after do
+        ActiveSupport::Notifications.
+          instrument 'process_action.action_controller'
+      end
     end
 
-    after do
-      ActiveSupport::Notifications.
-        instrument '!render_template'
+    context "event that starts with a bang" do
+      it "should not be processed" do
+        Appsignal::Transaction.should_not_receive(:current)
+      end
+
+      after do
+        ActiveSupport::Notifications.
+          instrument '!render_template'
+      end
     end
   end
 end

data/spec/appsignal/to_appsignal_hash_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Appsignal::ToAppsignalHash do
+  subject { notification_event }
+
+  it { should be_instance_of ActiveSupport::Notifications::Event }
+  it { should respond_to(:to_appsignal_hash) }
+
+  describe "#to_appsignal_hash" do
+    subject { notification_event.to_appsignal_hash }
+
+    it { should == {
+      :time => 978364860.0,
+      :duration => 100.0,
+      :end => 978364860.1,
+      :name => "process_action.action_controller",
+      :payload => {
+        :path=>"/blog",
+        :action=>"show",
+        :controller=>"BlogPostsController",
+        :request_format=>"html",
+        :request_method=>"GET",
+        :status=>"200",
+        :view_runtime=>500,
+        :db_runtime=>500
+      }
+    } }
+  end
+end

data/spec/appsignal/transaction/params_sanitizer_spec.rb

@@ -1,66 +1,171 @@
 require 'spec_helper'
 
 describe Appsignal::ParamsSanitizer do
-  describe ".sanitize" do
-    let(:file) { ActionDispatch::Http::UploadedFile.new(:tempfile => '/tmp') }
-    let(:params) do
-      {
-        :text => 'string',
-        :file => file,
-        :hash => {
-          :nested_text => 'string',
-          :nested_array => [
-            'something',
-            'else',
-            file,
-            {
-              :key => 'value',
-              :nested_array_hash_file => file,
-            }
-          ]
-        }
+  let(:file) { ActionDispatch::Http::UploadedFile.new(:tempfile => '/tmp') }
+  let(:params) do
+    {
+      :text => 'string',
+      :file => file,
+      :hash => {
+        :nested_text => 'string',
+        :nested_array => [
+          'something',
+          'else',
+          file,
+          {
+            :key => 'value',
+            :file => file,
+          }
+        ]
       }
+    }
+  end
+  let(:sanitized_params) { Appsignal::ParamsSanitizer.sanitize(params) }
+  let(:scrubbed_params) { Appsignal::ParamsSanitizer.scrub(params) }
+
+  describe ".sanitize!" do
+    subject { params }
+    before { Appsignal::ParamsSanitizer.sanitize!(subject) }
+
+    it { should be_instance_of Hash }
+    its([:text]) { should == 'string' }
+    its([:file]) { should be_instance_of String }
+    its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+
+    context "hash" do
+      subject { params[:hash] }
+
+      it { should be_instance_of Hash }
+      its([:nested_text]) { should == 'string' }
+
+      context "nested_array" do
+        subject { params[:hash][:nested_array] }
+
+        it { should be_instance_of Array }
+        its([0]) { should == 'something' }
+        its([1]) { should == 'else' }
+        its([2]) { should be_instance_of String }
+        its([2]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+
+        context "nested hash" do
+          subject { params[:hash][:nested_array][3] }
+
+          it { should be_instance_of Hash }
+          its([:key]) { should == 'value' }
+          its([:file]) { should be_instance_of String }
+          its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+        end
+      end
     end
-    let(:sanitized_params) { Appsignal::ParamsSanitizer.sanitize(params) }
+  end
 
+  describe ".sanitize" do
     subject { sanitized_params }
 
     it { should be_instance_of Hash }
-    it('should have a text') { subject[:text].should == 'string' }
-    it('should have a file') do
-      subject[:file].should be_instance_of String
-      subject[:file].should include '#<ActionDispatch::Http::UploadedFile:'
+    its([:text]) { should == 'string' }
+    its([:file]) { should be_instance_of String }
+    its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
+
+    it "does not change the original params" do
+      subject
+      params[:file].should == file
+      params[:hash][:nested_array][2].should == file
     end
 
     context "hash" do
       subject { sanitized_params[:hash] }
 
       it { should be_instance_of Hash }
-      it('should have a nested text') { subject[:nested_text].should == 'string' }
+      its([:nested_text]) { should == 'string' }
 
       context "nested_array" do
         subject { sanitized_params[:hash][:nested_array] }
 
         it { should be_instance_of Array }
+        its([0]) { should == 'something' }
+        its([1]) { should == 'else' }
+        its([2]) { should be_instance_of String }
+        its([2]) { should include '#<ActionDispatch::Http::UploadedFile:' }
 
-        it("should have two string items") do
-          subject.first.should == 'something'
-          subject.second.should == 'else'
+        context "nested hash" do
+          subject { sanitized_params[:hash][:nested_array][3] }
+
+          it { should be_instance_of Hash }
+          its([:key]) { should == 'value' }
+          its([:file]) { should be_instance_of String }
+          its([:file]) { should include '#<ActionDispatch::Http::UploadedFile:' }
         end
-        it "should have a file" do
-          subject.third.should be_instance_of String
-          subject.third.should include '#<ActionDispatch::Http::UploadedFile:'
+      end
+    end
+  end
+
+  describe ".scrub!" do
+    subject { params }
+    before { Appsignal::ParamsSanitizer.scrub!(subject) }
+
+    it { should be_instance_of Hash }
+    its([:text]) { should == '?' }
+    its([:file]) { should == '?' }
+
+    context "hash" do
+      subject { params[:hash] }
+
+      it { should be_instance_of Hash }
+      its([:nested_text]) { should == '?' }
+
+      context "nested_array" do
+        subject { params[:hash][:nested_array] }
+
+        it { should be_instance_of Array }
+        its([0]) { should == '?' }
+        its([1]) { should == '?' }
+        its([2]) { should == '?' }
+
+        context "nested hash" do
+          subject { params[:hash][:nested_array][3] }
+
+          it { should be_instance_of Hash }
+          its([:key]) { should == '?' }
+          its([:file]) { should == '?' }
         end
+      end
+    end
+  end
+
+  describe ".scrub" do
+    subject { scrubbed_params }
+
+     it "does not change the original params" do
+      subject
+      params[:file].should == file
+      params[:hash][:nested_array][2].should == file
+    end
+
+    it { should be_instance_of Hash }
+    its([:text]) { should == '?' }
+    its([:file]) { should == '?' }
+
+    context "hash" do
+      subject { scrubbed_params[:hash] }
+
+      it { should be_instance_of Hash }
+      its([:nested_text]) { should == '?' }
+
+      context "nested_array" do
+        subject { scrubbed_params[:hash][:nested_array] }
+
+        it { should be_instance_of Array }
+        its([0]) { should == '?' }
+        its([1]) { should == '?' }
+        its([2]) { should == '?' }
 
         context "nested hash" do
-          subject { sanitized_params[:hash][:nested_array].fourth }
+          subject { scrubbed_params[:hash][:nested_array][3] }
 
           it { should be_instance_of Hash }
-          it('should have a text') { subject[:key].should == 'value' }
-          it('should have a file') do
-            subject[:nested_array_hash_file].should be_instance_of String
-            subject[:nested_array_hash_file].should include '#<ActionDispatch::Http::UploadedFile:'
-          end
+          its([:key]) { should == '?' }
+          its([:file]) { should == '?' }
         end
       end
     end

data/spec/appsignal/transaction/transaction_formatter_spec.rb

@@ -3,175 +3,80 @@ require 'spec_helper'
 describe Appsignal::TransactionFormatter do
   let(:klass) { Appsignal::TransactionFormatter }
   let(:formatter) { klass.new(transaction) }
-  let(:transaction) do
-    Appsignal::Transaction.create('1', {
-      'HTTP_USER_AGENT' => 'IE6',
-      'SERVER_NAME' => 'localhost',
-      'action_dispatch.routes' => 'not_available'
-    })
-  end
   subject { formatter }
-
-  describe ".regular" do
-    subject { klass.regular(transaction) }
-    it { should be_a klass::RegularRequestFormatter }
-  end
-
-  describe ".slow" do
-    subject { klass.slow(transaction) }
-    it { klass.slow(transaction).should be_a klass::SlowRequestFormatter }
-  end
-
-  describe ".faulty" do
-    subject { klass.faulty(transaction) }
-    it { should be_a klass::FaultyRequestFormatter }
-  end
-
-  context "a new formatter" do
-    describe "#to_hash" do
-      subject { formatter.to_hash }
-      before { formatter.stub(:action => :foo, :formatted_process_action_event => :bar) }
-
-      it 'returns a formatted hash of the transaction data' do
-        should == {
-          :request_id => '1',
-          :action => :foo,
-          :log_entry => :bar,
-          :failed => false
-        }
-      end
+  before { transaction.stub(:fullpath => '/foo') }
+
+  describe "#to_hash" do
+    before { formatter.to_hash }
+    subject { formatter.hash }
+
+    context "with a regular request" do
+      let(:transaction) { regular_transaction }
+
+      its(:keys) { should == [:request_id, :log_entry, :failed] }
+      its([:request_id]) { should == '1' }
+      its([:log_entry]) { should == {
+          :action => "BlogPostsController#show",
+          :db_runtime => 500,
+          :duration => 100.0,
+          :end => 978364860.1,
+          :environment => {},
+          :kind => "http_request",
+          :path => "/blog",
+          :request_format => "html",
+          :request_method => "GET",
+          :session_data => {},
+          :status => "200",
+          :time => 978364860.0,
+          :view_runtime => 500
+      } }
+      its([:failed]) { should be_false }
     end
-  end
-
-  # protected
-
-  it { should delegate(:id).to(:transaction) }
-  it { should delegate(:events).to(:transaction) }
-  it { should delegate(:exception).to(:transaction) }
-  it { should delegate(:exception?).to(:transaction) }
-  it { should delegate(:env).to(:transaction) }
-  it { should delegate(:request).to(:transaction) }
-  it { should delegate(:process_action_event).to(:transaction) }
-  it { should delegate(:action).to(:transaction) }
 
-  it { should delegate(:payload).to(:process_action_event) }
-
-  context "a new formatter" do
-    describe "#formatted_process_action_event" do
-      subject { formatter.send(:formatted_process_action_event) }
-
-      it "calls basic_process_action_event" do
-        formatter.should_receive(:basic_process_action_event)
-        subject
-      end
+    context "with an exception request" do
+      let(:transaction) { transaction_with_exception }
 
-      context "with actual process action event data" do
-        before { transaction.set_process_action_event(create_process_action_event) }
+      its(:keys) { should == [:request_id, :log_entry, :failed, :exception] }
+      its([:request_id]) { should == '1' }
+      its([:failed]) { should be_true }
 
-        it { should be_a Hash }
+      context "exception content" do
+        subject { formatter.hash[:exception] }
 
-        it "merges formatted_payload on the basic_process_action_event" do
-          subject[:duration].should == 1000.0
-          subject[:action].should == 'BlogPostsController#show'
-        end
-      end
-
-      context "without any process action event data" do
-        it { should be_a Hash }
-
-        it "does not merge formatted_payload onto the basic_process_action_event" do
-          subject.keys.should_not include :duration
-          subject.keys.should_not include :action
-        end
+        its(:keys) { should == [:backtrace, :exception, :message] }
+        its([:backtrace]) { should be_instance_of Array }
+        its([:exception]) { should == 'ArgumentError' }
+        its([:message]) { should == 'oh no' }
       end
     end
 
-    describe "#basic_process_action_event" do
-      subject { formatter.send(:basic_process_action_event) }
-      before do
-        transaction.stub(:request => mock(
-          :fullpath => '/blog',
-          :session => {:current_user => 1})
-        )
-      end
+    context "with a slow request" do
+      let(:transaction) { slow_transaction }
 
-      it { should == {
-        :path => '/blog',
-        :kind => 'http_request'
-      } }
+      its(:keys) { should == [:request_id, :log_entry, :failed, :events] }
+      its([:request_id]) { should == '1' }
+      its([:failed]) { should be_false }
 
-      it "has no environment key" do
-        subject[:environment].should be_nil
-      end
-
-      it "has no session_data key" do
-        subject[:session_data].should be_nil
-      end
-    end
+      context "events content" do
+        subject { formatter.hash[:events] }
 
-    describe "#formatted_payload" do
-      let(:start_time) { Time.at(2.71828182) }
-      let(:end_time) { Time.at(3.141592654) }
-      subject { formatter.send(:formatted_payload) }
-      before do
-        transaction.stub(:sanitized_event_payload => {})
-        transaction.set_process_action_event(mock(
-          :name => 'name',
-          :duration => 2,
-          :time => start_time,
-          :end => end_time,
+        its(:length) { should == 1 }
+        its(:first) { should == {
+          :name => "query.mongoid",
+          :duration => 100.0,
+          :time => 978364860.0,
+          :end => 978364860.1,
           :payload => {
-            :controller => 'controller',
-            :action => 'action'
+            :path => "/blog",
+            :action => "show",
+            :controller => "BlogPostsController",
+            :request_format => "html",
+            :request_method => "GET",
+            :status => "200",
+            :view_runtime => 500,
+            :db_runtime => 500
           }
-        ))
-      end
-
-      it { should == {
-        :action => 'controller#action',
-        :controller => 'controller', # DEBUG this should no longer be here now
-        :duration => 2,
-        :time => start_time.to_f,
-        :end => end_time.to_f
-      } }
-    end
-
-    describe "#sanitized_event_payload" do
-      subject do
-        formatter.send(:sanitized_event_payload, double(:payload => {:key => :sensitive}))
-      end
-
-      it "calls Appsignal event payload sanitizer" do
-        Appsignal.should_receive(:event_payload_sanitizer).and_return(
-          proc do |event|
-            event.payload[:key] = 'censored'
-            event.payload
-          end
-        )
-        subject.should == {:key => 'censored'}
-      end
-
-      it "calls params sanitizer" do
-        Appsignal::ParamsSanitizer.should_receive(:sanitize).and_return(
-          :key => 'sensitive'
-        )
-        subject.should == {:key => 'sensitive'}
-      end
-    end
-
-    describe "#filtered_environment" do
-      subject { formatter.send(:filtered_environment) }
-
-      it "should have a SERVER_NAME" do
-        subject['SERVER_NAME'].should == 'localhost'
-      end
-
-      it "should have a HTTP_USER_AGENT" do
-        subject['HTTP_USER_AGENT'].should == 'IE6'
-      end
-
-      it "should not have a action_dispatch.routes" do
-        subject.should_not have_key 'action_dispatch.routes'
+        } }
       end
     end
   end