appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

data/spec/lib/appsignal/transmitter_spec.rb

@@ -1,21 +1,21 @@
 describe Appsignal::Transmitter do
   let(:config) { project_fixture_config }
-  let(:action) { 'action' }
+  let(:action) { "action" }
   let(:log) { StringIO.new }
   let(:instance) { Appsignal::Transmitter.new(action, config) }
   before do
-    config.config_hash[:hostname] = 'app1.local'
+    config.config_hash[:hostname] = "app1.local"
     config.logger = Logger.new(log)
   end
 
   describe "#uri" do
     subject { instance.uri.to_s }
 
-    it { should include 'https://push.appsignal.com/1/action?' }
-    it { should include 'api_key=abc' }
-    it { should include 'hostname=app1.local' }
-    it { should include 'name=TestApp' }
-    it { should include 'environment=production' }
+    it { should include "https://push.appsignal.com/1/action?" }
+    it { should include "api_key=abc" }
+    it { should include "hostname=app1.local" }
+    it { should include "name=TestApp" }
+    it { should include "environment=production" }
     it { should include "gem_version=#{Appsignal::VERSION}" }
   end
 
@@ -29,8 +29,8 @@ describe Appsignal::Transmitter do
       ).with(
         :body => Appsignal::Utils::Gzip.compress("{\"the\":\"payload\"}"),
         :headers => {
-          'Content-Encoding' => 'gzip',
-          'Content-Type' => 'application/json; charset=UTF-8',
+          "Content-Encoding" => "gzip",
+          "Content-Type" => "application/json; charset=UTF-8"
         }
       ).to_return(
         :status => 200
@@ -38,7 +38,7 @@ describe Appsignal::Transmitter do
     end
     subject { instance.transmit(:the => :payload) }
 
-    it { should eq '200' }
+    it { should eq "200" }
 
     context "with ca_file_path config option set" do
       context "when not existing file" do
@@ -47,7 +47,7 @@ describe Appsignal::Transmitter do
         end
 
         it "ignores the config and logs a warning" do
-          expect(subject).to eq '200'
+          expect(subject).to eq "200"
           expect(log.string).to_not include "Ignoring non-existing or unreadable " \
             "`ca_file_path`: #{config[:ca_file_path]}"
         end
@@ -59,7 +59,7 @@ describe Appsignal::Transmitter do
         end
 
         it "ignores the config and logs a warning" do
-          expect(subject).to eq '200'
+          expect(subject).to eq "200"
           expect(log.string).to include "Ignoring non-existing or unreadable " \
             "`ca_file_path`: #{config[:ca_file_path]}"
         end
@@ -73,7 +73,7 @@ describe Appsignal::Transmitter do
         end
 
         it "ignores the config and logs a warning" do
-          expect(subject).to eq '200'
+          expect(subject).to eq "200"
           expect(log.string).to include "Ignoring non-existing or unreadable " \
             "`ca_file_path`: #{config[:ca_file_path]}"
         end
@@ -84,14 +84,14 @@ describe Appsignal::Transmitter do
   end
 
   describe "#http_post" do
-    subject { instance.send(:http_post, 'the' => 'payload') }
+    subject { instance.send(:http_post, "the" => "payload") }
 
     its(:body) { should eq Appsignal::Utils::Gzip.compress("{\"the\":\"payload\"}") }
     its(:path) { should eq instance.uri.request_uri }
 
     it "should have the correct headers" do
-      subject['Content-Type'].should eq 'application/json; charset=UTF-8'
-      subject['Content-Encoding'].should eq 'gzip'
+      subject["Content-Type"].should eq "application/json; charset=UTF-8"
+      subject["Content-Encoding"].should eq "gzip"
     end
   end
 
@@ -99,7 +99,7 @@ describe Appsignal::Transmitter do
     subject { instance.send(:http_client) }
 
     context "with a http uri" do
-      let(:config) { project_fixture_config('test') }
+      let(:config) { project_fixture_config("test") }
 
       it { should be_instance_of(Net::HTTP) }
       its(:proxy?) { should be_false }
@@ -107,7 +107,7 @@ describe Appsignal::Transmitter do
     end
 
     context "with a https uri" do
-      let(:config) { project_fixture_config('production') }
+      let(:config) { project_fixture_config("production") }
 
       it { should be_instance_of(Net::HTTP) }
       its(:proxy?) { should be_false }
@@ -117,10 +117,10 @@ describe Appsignal::Transmitter do
     end
 
     context "with a proxy" do
-      let(:config) { project_fixture_config('production', :http_proxy => 'http://localhost:8080') }
+      let(:config) { project_fixture_config("production", :http_proxy => "http://localhost:8080") }
 
       its(:proxy?) { should be_true }
-      its(:proxy_address) { should eq 'localhost' }
+      its(:proxy_address) { should eq "localhost" }
       its(:proxy_port) { should eq 8080 }
     end
   end

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

@@ -2,8 +2,8 @@ describe Appsignal::Utils::ParamsSanitizer do
   let(:file) { uploaded_file }
   let(:params) do
     {
-      :text       => 'string',
-      'string'    => 'string key value',
+      :text       => "string",
+      "string"    => "string key value",
       :file       => file,
       :float      => 0.0,
       :bool_true  => true,
@@ -11,13 +11,13 @@ describe Appsignal::Utils::ParamsSanitizer do
       :nil        => nil,
       :int        => 1,
       :hash       => {
-        :nested_text  => 'string',
+        :nested_text  => "string",
         :nested_array => [
-          'something',
-          'else',
+          "something",
+          "else",
           file,
           {
-            :key  => 'value',
+            :key  => "value",
             :file => file
           }
         ]
@@ -30,10 +30,10 @@ describe Appsignal::Utils::ParamsSanitizer do
     subject { sanitized_params }
 
     it { should be_instance_of Hash }
-    its([:text]) { should eq('string') }
-    its(['string']) { should eq('string key value') }
+    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([:file]) { should include "::UploadedFile" }
     its([:float]) { should eq(0.0) }
     its([:bool_true]) { should be(true) }
     its([:bool_false]) { should be(false) }
@@ -50,24 +50,24 @@ describe Appsignal::Utils::ParamsSanitizer do
       subject { sanitized_params[:hash] }
 
       it { should be_instance_of Hash }
-      its([:nested_text]) { should eq('string') }
+      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([0]) { should eq("something") }
+        its([1]) { should eq("else") }
         its([2]) { should be_instance_of String }
-        its([2]) { should include '::UploadedFile' }
+        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([:key]) { should eq("value") }
           its([:file]) { should be_instance_of String }
-          its([:file]) { should include '::UploadedFile' }
+          its([:file]) { should include "::UploadedFile" }
         end
       end
     end
@@ -81,7 +81,7 @@ describe Appsignal::Utils::ParamsSanitizer do
       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([:file]) { should include "::UploadedFile" }
       its([:float]) { should eq(0.0) }
       its([:bool_true]) { should be(true) }
       its([:bool_false]) { should be(false) }
@@ -93,7 +93,7 @@ describe Appsignal::Utils::ParamsSanitizer do
           described_class.sanitize(params, :filter_parameters => %w(string))
         end
 
-        its(['string']) { should eq('[FILTERED]') }
+        its(["string"]) { should eq("[FILTERED]") }
       end
 
       describe ":hash" do
@@ -102,7 +102,7 @@ describe Appsignal::Utils::ParamsSanitizer do
         end
         subject { sanitized_params[:hash] }
 
-        its([:nested_text]) { should eq('[FILTERED]') }
+        its([:nested_text]) { should eq("[FILTERED]") }
 
         describe ":nested_array" do
           describe ":nested_hash" do
@@ -111,7 +111,7 @@ describe Appsignal::Utils::ParamsSanitizer do
             end
             subject { sanitized_params[:hash][:nested_array][3] }
 
-            its([:key]) { should eq('[FILTERED]') }
+            its([:key]) { should eq("[FILTERED]") }
           end
         end
       end

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

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

data/spec/lib/appsignal/utils_spec.rb

@@ -7,54 +7,56 @@ describe Appsignal::Utils do
     context "with a valid hash body" do
       let(:body) do
         {
-          'the' => 'payload',
-          'int' => 1,
-          'float' => 1.0,
+          "the" => "payload",
+          "int" => 1,
+          "float" => 1.0,
           1 => true,
-          nil => 'test',
-          :foo => [1, 2, 'three', {'foo' => 'bar'}],
-          'bar' => nil,
-          'baz' => {'foo' => 'bʊr', 'arr' => [1, 2]}
+          nil => "test",
+          :foo => [1, 2, "three", { "foo" => "bar" }],
+          "bar" => nil,
+          "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
         }
       end
 
       it { should eq Appsignal::Utils.data_generate(body) }
       it { should_not eq Appsignal::Utils.data_generate({}) }
-      it { should_not eq 'a string' }
+      it { should_not eq "a string" }
       its(:to_s) { should eq %({"":"test","1":true,"bar":null,"baz":{"arr":[1,2],"foo":"bʊr"},"float":1.0,"foo":[1,2,"three",{"foo":"bar"}],"int":1,"the":"payload"}) }
     end
 
     context "with a valid array body" do
       let(:body) do
-        [1, 'string', 10, {'foo' => 'bʊr'}]
+        [1, "string", 10, { "foo" => "bʊr" }]
       end
 
       its(:to_s) { should eq %([1,\"string\",10,{\"foo\":\"bʊr\"}]) }
     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_three' => [
-          'one', string_with_invalid_utf8
-        ],
-        'field_four' => {
-          'one' => string_with_invalid_utf8
+      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
+      let(:body) do
+        {
+          "field_one" => [0x61, 0x61].pack("c*"),
+          :field_two => string_with_invalid_utf8,
+          "field_three" => [
+            "one", string_with_invalid_utf8
+          ],
+          "field_four" => {
+            "one" => string_with_invalid_utf8
+          }
         }
-      } }
+      end
 
       its(:to_s) { should eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"}) }
     end
 
     context "with an invalid body" do
-      let(:body) { 'body' }
+      let(:body) { "body" }
 
       it "should raise a type error" do
-        expect {
+        expect do
           subject
-        }.to raise_error TypeError
+        end.to raise_error TypeError
       end
     end
   end
@@ -65,12 +67,12 @@ describe Appsignal::Utils do
     context "with a valid body" do
       let(:body) do
         {
-          'the' => 'payload',
+          "the" => "payload",
           1 => true,
-          nil => 'test',
-          :foo => [1, 2, 'three'],
-          'bar' => nil,
-          'baz' => {'foo' => 'bar'}
+          nil => "test",
+          :foo => [1, 2, "three"],
+          "bar" => nil,
+          "baz" => { "foo" => "bar" }
         }
       end
 
@@ -78,17 +80,19 @@ describe Appsignal::Utils do
     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_three' => [
-          'one', string_with_invalid_utf8
-        ],
-        'field_four' => {
-          'one' => string_with_invalid_utf8
+      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
+      let(:body) do
+        {
+          "field_one" => [0x61, 0x61].pack("c*"),
+          :field_two => string_with_invalid_utf8,
+          "field_three" => [
+            "one", string_with_invalid_utf8
+          ],
+          "field_four" => {
+            "one" => string_with_invalid_utf8
+          }
         }
-      } }
+      end
 
       it { should eq %({"field_one":"aa","field_two":"aa�","field_three":["one","aa�"],"field_four":{"one":"aa�"}}) }
     end