appsignal 1.2.5 → 1.3.0.beta.1

data/spec/lib/appsignal/transmitter_spec.rb

@@ -6,7 +6,7 @@ describe Appsignal::Transmitter do
   let(:instance) { Appsignal::Transmitter.new(action, config) }
 
   describe "#uri" do
-    before { Socket.stub(:gethostname => 'app1.local') }
+    before { ENV['APPSIGNAL_HOSTNAME'] = 'app1.local' }
 
     subject { instance.uri.to_s }
 

data/spec/lib/appsignal/utils/params_sanitizer_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Appsignal::Utils::ParamsSanitizer do
+  let(:file) { uploaded_file }
+  let(:params) do
+    {
+      :text       => 'string',
+      'string'    => 'string key value',
+      :file       => file,
+      :float      => 0.0,
+      :bool_true  => true,
+      :bool_false => false,
+      :nil        => nil,
+      :int        => 1,
+      :hash       => {
+        :nested_text  => 'string',
+        :nested_array => [
+          'something',
+          'else',
+          file,
+          {
+            :key  => 'value',
+            :file => file
+          }
+        ]
+      }
+    }
+  end
+
+  describe ".sanitize" do
+    let(:sanitized_params) { described_class.sanitize(params) }
+    subject { sanitized_params }
+
+    it { should be_instance_of Hash }
+    its([:text]) { should eq('string') }
+    its(['string']) { should eq('string key value') }
+    its([:file]) { should be_instance_of String }
+    its([:file]) { should include '::UploadedFile' }
+    its([:float]) { should eq(0.0) }
+    its([:bool_true]) { should be(true) }
+    its([:bool_false]) { should be(false) }
+    its([:nil]) { should be_nil }
+    its([:int]) { should eq(1) }
+
+    it "does not change the original params" do
+      subject
+      params[:file].should eq(file)
+      params[:hash][:nested_array][2].should eq(file)
+    end
+
+    describe ":hash" do
+      subject { sanitized_params[:hash] }
+
+      it { should be_instance_of Hash }
+      its([:nested_text]) { should eq('string') }
+
+      describe ":nested_array" do
+        subject { sanitized_params[:hash][:nested_array] }
+
+        it { should be_instance_of Array }
+        its([0]) { should eq('something') }
+        its([1]) { should eq('else') }
+        its([2]) { should be_instance_of String }
+        its([2]) { should include '::UploadedFile' }
+
+        describe ":nested_hash" do
+          subject { sanitized_params[:hash][:nested_array][3] }
+
+          it { should be_instance_of Hash }
+          its([:key]) { should eq('value') }
+          its([:file]) { should be_instance_of String }
+          its([:file]) { should include '::UploadedFile' }
+        end
+      end
+    end
+
+    context "with :filter_parameters option" do
+      let(:sanitized_params) do
+        described_class.sanitize(params, :filter_parameters => %w(text hash))
+      end
+      subject { sanitized_params }
+
+      its([:text]) { should eq(described_class::FILTERED) }
+      its([:hash]) { should eq(described_class::FILTERED) }
+      its([:file]) { should be_instance_of String }
+      its([:file]) { should include '::UploadedFile' }
+      its([:float]) { should eq(0.0) }
+      its([:bool_true]) { should be(true) }
+      its([:bool_false]) { should be(false) }
+      its([:nil]) { should be_nil }
+      its([:int]) { should eq(1) }
+
+      context "with strings as key filter values" do
+        let(:sanitized_params) do
+          described_class.sanitize(params, :filter_parameters => %w(string))
+        end
+
+        its(['string']) { should eq('[FILTERED]') }
+      end
+
+      describe ":hash" do
+        let(:sanitized_params) do
+          described_class.sanitize(params, :filter_parameters => %w(nested_text))
+        end
+        subject { sanitized_params[:hash] }
+
+        its([:nested_text]) { should eq('[FILTERED]') }
+
+        describe ":nested_array" do
+          describe ":nested_hash" do
+            let(:sanitized_params) do
+              described_class.sanitize(params, :filter_parameters => %w(key))
+            end
+            subject { sanitized_params[:hash][:nested_array][3] }
+
+            its([:key]) { should eq('[FILTERED]') }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/utils/query_params_sanitizer_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Appsignal::Utils::QueryParamsSanitizer do
+  describe ".sanitize" do
+    context "when only_top_level = true" do
+      subject { described_class.sanitize(value, true) }
+
+      context "when value is a hash" do
+        let(:value) { {'foo' => 'bar'} }
+
+        it "should only return the first level of the object" do
+          expect(subject).to eq('foo' => '?')
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq('foo' => 'bar')
+        end
+      end
+
+      context "when value is a nested hash" do
+        let(:value) { {'foo' => { 'bar' => 'baz' }} }
+
+        it "should only return the first level of the object" do
+          expect(subject).to eq('foo' => '?')
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq('foo' => { 'bar' => 'baz' })
+        end
+      end
+
+      context "when value is an array of hashes" do
+        let(:value) { ['foo' => 'bar'] }
+
+        it "should sanitize all hash values with a questionmark" do
+          expect(subject).to eq('foo' => '?')
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq(['foo' => 'bar'])
+        end
+      end
+
+      context "when value is an array" do
+        let(:value) { ['foo', 'bar'] }
+
+        it "should only return the first level of the object" do
+          expect(subject).to eq('?')
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq(['foo', 'bar'])
+        end
+      end
+
+      context "when value is a mixed array" do
+        let(:value) { [nil, 'foo', 'bar'] }
+
+        it "should sanitize all hash values with a single questionmark" do
+          expect(subject).to eq('?')
+        end
+      end
+
+      context "when value is a string" do
+        let(:value) { 'foo' }
+
+        it "should sanitize all hash values with a questionmark" do
+          expect(subject).to eq('?')
+        end
+      end
+    end
+
+    context "when only_top_level = false" do
+      subject { described_class.sanitize(value, false) }
+
+      context "when value is a hash" do
+        let(:value) { {'foo' => 'bar'} }
+
+        it "should sanitize all hash values with a questionmark" do
+          expect(subject).to eq('foo' => '?')
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq('foo' => 'bar')
+        end
+      end
+
+      context "when value is a nested hash" do
+        let(:value) { {'foo' => { 'bar' => 'baz' }} }
+
+        it "should replaces values" do
+          expect(subject).to eq('foo' => {'bar' => '?'})
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq('foo' => {'bar' => 'baz'})
+        end
+      end
+
+      context "when value is an array of hashes" do
+        let(:value) { ['foo' => 'bar'] }
+
+        it "should sanitize all hash values with a questionmark" do
+          expect(subject).to eq(['foo' => '?'])
+        end
+
+        it "should not modify source value" do
+          subject
+          expect(value).to eq(['foo' => 'bar'])
+        end
+      end
+
+      context "when value is an array" do
+        let(:value) { ['foo', 'bar'] }
+
+        it "should sanitize all hash values with a single questionmark" do
+          expect(subject).to eq(['?'])
+        end
+      end
+
+      context "when value is a mixed array" do
+        let(:value) { [nil, 'foo', 'bar'] }
+
+        it "should sanitize all hash values with a single questionmark" do
+          expect(subject).to eq(['?'])
+        end
+      end
+
+      context "when value is a string" do
+        let(:value) { 'bar' }
+
+        it "should sanitize all hash values with a questionmark" do
+          expect(subject).to eq('?')
+        end
+      end
+    end
+  end
+
+  describe "key_sanitizer option" do
+    context "without key_sanitizer" do
+      subject { described_class.sanitize(value) }
+
+      context "when dots are in the key" do
+        let(:value) { {'foo.bar' => 'bar'} }
+
+        it "should not sanitize the key" do
+          expect(subject).to eql('foo.bar' => '?')
+        end
+      end
+
+      context "when key is a symbol" do
+        let(:value) { {:ismaster => 'bar'} }
+
+        it "should sanitize the key" do
+          expect(subject).to eql(:ismaster => '?')
+        end
+      end
+    end
+
+    context "with mongodb key_sanitizer" do
+      subject { described_class.sanitize(value, false, :mongodb) }
+
+      context "when no dots are in the key" do
+        let(:value) { {'foo' => 'bar'} }
+
+        it "should not sanitize the key" do
+          expect(subject).to eql('foo' => '?')
+        end
+      end
+
+      context "when dots are in the key" do
+        let(:value) { {'foo.bar' => 'bar'} }
+
+        it "should sanitize the key" do
+          expect(subject).to eql('foo.?' => '?')
+        end
+      end
+
+      context "when key is a symbol" do
+        let(:value) { {:ismaster => 'bar'} }
+
+        it "should sanitize the key" do
+          expect(subject).to eql('ismaster' => '?')
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/utils_spec.rb

@@ -3,82 +3,29 @@
 require 'spec_helper'
 
 describe Appsignal::Utils do
-  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( Appsignal::Utils.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( Appsignal::Utils.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( Appsignal::Utils.sanitize(params) ).to eq(['?'])
-      end
-    end
-
-    context "when params is a mixed array" do
-      let(:params) { [nil, 'foo', 'bar'] }
-
-      it "should sanitize all hash values with a single questionmark" do
-        expect( Appsignal::Utils.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( Appsignal::Utils.sanitize(params) ).to eq('?')
-      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
-
-      it "should sanitize a symbol" do
-        expect( Appsignal::Utils.sanitize_key(:ismaster, :mongodb) ).to eql('ismaster')
-      end
-    end
-  end
-
   describe ".json_generate" do
     subject { Appsignal::Utils.json_generate(body) }
 
     context "with a valid body" do
-      let(:body) { {'the' => 'payload'} }
+      let(:body) do
+        {
+          'the' => 'payload',
+          1 => true,
+          nil => 'test',
+          :foo => [1, 2, 'three'],
+          'bar' => nil,
+          'baz' => { 'foo' => 'bar' }
+        }
+      end
 
-      it { should == "{\"the\":\"payload\"}" }
+      it { should == %({"the":"payload","1":true,"":"test","foo":[1,2,"three"],"bar":null,"baz":{"foo":"bar"}}) }
     end
 
     context "with a body that contains strings with invalid utf-8 content" do
       let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack('c*') }
       let(:body) { {
         'field_one' => [0x61, 0x61].pack('c*'),
-        'field_two' => string_with_invalid_utf8,
+        :field_two => string_with_invalid_utf8,
         'field_three' => [
           'one', string_with_invalid_utf8
         ],
@@ -87,17 +34,7 @@ describe Appsignal::Utils do
         }
       } }
 
-      it { should == "{\"field_one\":\"aa\",\"field_two\":\"aa�\",\"field_three\":[\"one\",\"aa�\"],\"field_four\":{\"one\":\"aa�\"}}" }
-    end
-  end
-
-  describe ".encode_utf8" do
-    subject { Appsignal::Utils.encode_utf8(value) }
-
-    context "value with invalid utf-8 content" do
-      let(:value) { [0x61, 0x61, 0x85].pack('c*') }
-
-      it { should == "aa�" }
+      it { should == %({"field_one":"aa","field_two":"aa�","field_three":["one","aa�"],"field_four":{"one":"aa�"}}) }
     end
   end
 end

data/spec/lib/appsignal_spec.rb

@@ -101,6 +101,11 @@ describe Appsignal do
           Appsignal::Extension.should_receive(:install_gc_event_hooks)
           Appsignal.start
         end
+
+        it "should add the gc probe to minutely" do
+          Appsignal::Minutely.should_receive(:add_gc_probe)
+          Appsignal.start
+        end
       end
 
       context "when allocation tracking and gc instrumentation have been disabled" do
@@ -114,6 +119,33 @@ describe Appsignal do
           Appsignal::Extension.should_not_receive(:install_gc_event_hooks)
           Appsignal.start
         end
+
+       it "should not add the gc probe to minutely" do
+          Appsignal::Minutely.should_not_receive(:add_gc_probe)
+          Appsignal.start
+       end
+      end
+
+      context "when minutely metrics has been enabled" do
+        before do
+          Appsignal.config.config_hash[:enable_minutely_probes] = true
+        end
+
+        it "should start minutely" do
+          Appsignal::Minutely.should_receive(:start)
+          Appsignal.start
+        end
+      end
+
+      context "when minutely metrics has been disabled" do
+        before do
+          Appsignal.config.config_hash[:enable_minutely_probes] = false
+        end
+
+        it "should not start minutely" do
+          Appsignal::Minutely.should_not_receive(:start)
+          Appsignal.start
+        end
       end
     end
 
@@ -266,6 +298,19 @@ describe Appsignal do
         }.should_not raise_error
       end
     end
+
+    describe ".instrument" do
+      it "should not instrument, but still call the block" do
+        stub = double
+        stub.should_receive(:method_call).and_return('return value')
+
+        lambda {
+          Appsignal.instrument 'name' do
+            stub.method_call
+          end.should eq 'return value'
+        }.should_not raise_error
+      end
+    end
   end
 
   context "with config and started" do
@@ -393,14 +438,14 @@ describe Appsignal do
 
     describe "custom stats" do
       describe ".set_gauge" do
-        it "should call set_gauge on the extension with a float" do
+        it "should call set_gauge on the extension with a string key and float" do
           Appsignal::Extension.should_receive(:set_gauge).with('key', 0.1)
           Appsignal.set_gauge('key', 0.1)
         end
 
-        it "should call set_gauge on the extension with an int" do
+        it "should call set_gauge on the extension with a symbol key and int" do
           Appsignal::Extension.should_receive(:set_gauge).with('key', 1.0)
-          Appsignal.set_gauge('key', 1)
+          Appsignal.set_gauge(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
@@ -413,14 +458,14 @@ describe Appsignal do
       end
 
       describe ".set_host_gauge" do
-        it "should call set_host_gauge on the extension with a float" do
+        it "should call set_host_gauge on the extension with a string key and float" do
           Appsignal::Extension.should_receive(:set_host_gauge).with('key', 0.1)
           Appsignal.set_host_gauge('key', 0.1)
         end
 
-        it "should call set_host_gauge on the extension with an int" do
+        it "should call set_host_gauge on the extension with a symbol key and int" do
           Appsignal::Extension.should_receive(:set_host_gauge).with('key', 1.0)
-          Appsignal.set_host_gauge('key', 1)
+          Appsignal.set_host_gauge(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
@@ -433,14 +478,14 @@ describe Appsignal do
       end
 
       describe ".set_process_gauge" do
-        it "should call set_process_gauge on the extension with a float" do
+        it "should call set_process_gauge on the extension with a string key and float" do
           Appsignal::Extension.should_receive(:set_process_gauge).with('key', 0.1)
           Appsignal.set_process_gauge('key', 0.1)
         end
 
-        it "should call set_process_gauge on the extension with an int" do
+        it "should call set_process_gauge on the extension with a symbol key and int" do
           Appsignal::Extension.should_receive(:set_process_gauge).with('key', 1.0)
-          Appsignal.set_process_gauge('key', 1)
+          Appsignal.set_process_gauge(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
@@ -453,11 +498,16 @@ describe Appsignal do
       end
 
       describe ".increment_counter" do
-        it "should call increment_counter on the extension" do
+        it "should call increment_counter on the extension with a string key" do
           Appsignal::Extension.should_receive(:increment_counter).with('key', 1)
           Appsignal.increment_counter('key')
         end
 
+        it "should call increment_counter on the extension with a symbol key" do
+          Appsignal::Extension.should_receive(:increment_counter).with('key', 1)
+          Appsignal.increment_counter(:key)
+        end
+
         it "should call increment_counter on the extension with a count" do
           Appsignal::Extension.should_receive(:increment_counter).with('key', 5)
           Appsignal.increment_counter('key', 5)
@@ -473,14 +523,14 @@ describe Appsignal do
       end
 
       describe ".add_distribution_value" do
-        it "should call add_distribution_value on the extension with a float" do
+        it "should call add_distribution_value on the extension with a string key and float" do
           Appsignal::Extension.should_receive(:add_distribution_value).with('key', 0.1)
           Appsignal.add_distribution_value('key', 0.1)
         end
 
-        it "should call add_distribution_value on the extension with an int" do
+        it "should call add_distribution_value on the extension with a symbol key and int" do
           Appsignal::Extension.should_receive(:add_distribution_value).with('key', 1.0)
-          Appsignal.add_distribution_value('key', 1)
+          Appsignal.add_distribution_value(:key, 1)
         end
 
         it "should not raise an exception when out of range" do
@@ -676,6 +726,25 @@ describe Appsignal do
       end
     end
 
+    describe ".instrument" do
+      it "should instrument through the transaction" do
+        stub = double
+        stub.should_receive(:method_call).and_return('return value')
+
+        transaction.should_receive(:start_event)
+        transaction.should_receive(:finish_event).with(
+          'name',
+          'title',
+          'body',
+          0
+        )
+
+        Appsignal.instrument 'name', 'title', 'body' do
+          stub.method_call
+        end.should eq 'return value'
+      end
+    end
+
     describe ".without_instrumentation" do
       let(:transaction) { double }
       before { Appsignal::Transaction.stub(:current => transaction) }