appsignal 4.0.6 → 4.0.8

data/spec/lib/appsignal/transmitter_spec.rb

@@ -1,198 +0,0 @@
-describe Appsignal::Transmitter do
-  let(:config) do
-    build_config(:options => { :hostname => "app1.local" }, :logger => Logger.new(log))
-  end
-  let(:base_uri) { "action" }
-  let(:log) { StringIO.new }
-  let(:instance) { Appsignal::Transmitter.new(base_uri, config) }
-
-  describe "#uri" do
-    let(:uri) { instance.uri }
-
-    it "returns a URI object with configuration data" do
-      expect(uri.to_s).to start_with(config[:endpoint])
-      expect(uri.path).to eq("/1/action")
-      expect(CGI.parse(uri.query)).to eq(
-        "api_key" => ["abc"],
-        "hostname" => ["app1.local"],
-        "name" => ["TestApp"],
-        "environment" => ["production"],
-        "gem_version" => [Appsignal::VERSION]
-      )
-    end
-
-    context "when base_uri argument is a full URI" do
-      let(:base_uri) { "http://foo.bar/path" }
-
-      it "uses the full URI" do
-        expect(uri.to_s).to start_with("#{base_uri}?")
-      end
-    end
-
-    context "when base_uri argument is only a path" do
-      it "uses the config[:endpoint] base" do
-        expect(uri.to_s).to start_with("#{config[:endpoint]}/1/#{base_uri}?")
-      end
-    end
-  end
-
-  describe "#transmit" do
-    before do
-      stub_request(:post, "https://push.appsignal.com/1/action").with(
-        :query => {
-          :api_key => "abc",
-          :environment => "production",
-          :gem_version => Appsignal::VERSION,
-          :hostname => config[:hostname],
-          :name => "TestApp"
-        },
-        :body => "{\"the\":\"payload\"}",
-        :headers => {
-          "Content-Type" => "application/json; charset=UTF-8"
-        }
-      ).to_return(:status => 200)
-    end
-
-    let(:response) { instance.transmit({ :the => :payload }) }
-
-    it "returns Net::HTTP response" do
-      expect(response).to be_kind_of(Net::HTTPResponse)
-      expect(response.code).to eq "200"
-    end
-
-    describe "with :ndjson format" do
-      before do
-        stub_request(:post, "https://push.appsignal.com/1/action").with(
-          :query => {
-            :api_key => "abc",
-            :environment => "production",
-            :gem_version => Appsignal::VERSION,
-            :hostname => config[:hostname],
-            :name => "TestApp"
-          },
-          :body => "{\"the\":\"payload\"}\n{\"part\":\"two\"}",
-          :headers => {
-            "Content-Type" => "application/x-ndjson; charset=UTF-8"
-          }
-        ).to_return(:status => 200)
-      end
-
-      let(:response) do
-        instance.transmit([{ :the => :payload }, { :part => :two }], :format => :ndjson)
-      end
-
-      it "returns Net::HTTP response" do
-        expect(response).to be_kind_of(Net::HTTPResponse)
-        expect(response.code).to eq "200"
-      end
-    end
-
-    context "with ca_file_path config option set" do
-      context "when file does not exist" do
-        before do
-          config.config_hash[:ca_file_path] = File.join(resources_dir, "cacert.pem")
-        end
-
-        it "ignores the config and logs a warning" do
-          expect(response).to be_kind_of(Net::HTTPResponse)
-          expect(response.code).to eq "200"
-          expect(log.string).to_not include "Ignoring non-existing or unreadable " \
-            "`ca_file_path`: #{config[:ca_file_path]}"
-        end
-      end
-
-      context "when not existing file" do
-        before do
-          config.config_hash[:ca_file_path] = File.join(tmp_dir, "ca_file_that_does_not_exist")
-        end
-
-        it "ignores the config and logs a warning" do
-          expect(response).to be_kind_of(Net::HTTPResponse)
-          expect(response.code).to eq "200"
-          expect(log.string).to include "Ignoring non-existing or unreadable " \
-            "`ca_file_path`: #{config[:ca_file_path]}"
-        end
-      end
-
-      context "when not readable file" do
-        let(:file) { File.join(tmp_dir, "ca_file") }
-        before do
-          config.config_hash[:ca_file_path] = file
-          File.open(file, "w") { |f| f.chmod 0o000 }
-        end
-
-        it "ignores the config and logs a warning" do
-          expect(response).to be_kind_of(Net::HTTPResponse)
-          expect(response.code).to eq "200"
-          expect(log.string).to include "Ignoring non-existing or unreadable " \
-            "`ca_file_path`: #{config[:ca_file_path]}"
-        end
-
-        after { File.delete file }
-      end
-    end
-  end
-
-  describe "#http_post" do
-    subject { instance.send(:http_post, { "the" => "payload" }, :format => :json) }
-
-    it "sets the path" do
-      expect(subject.path).to eq instance.uri.request_uri
-    end
-
-    it "sets the correct headers" do
-      expect(subject["Content-Type"]).to eq "application/json; charset=UTF-8"
-    end
-
-    it "serialises the payload to JSON" do
-      expect(subject.body).to eq "{\"the\":\"payload\"}"
-    end
-
-    describe "with :ndjson format" do
-      subject do
-        instance.send(:http_post, [{ "the" => "payload" }, { "part" => "two" }], :format => :ndjson)
-      end
-
-      it "sets the correct headers" do
-        expect(subject["Content-Type"]).to eq "application/x-ndjson; charset=UTF-8"
-      end
-
-      it "serialises the payload to NDJSON" do
-        expect(subject.body).to eq "{\"the\":\"payload\"}\n{\"part\":\"two\"}"
-      end
-    end
-  end
-
-  describe "#http_client" do
-    subject { instance.send(:http_client) }
-
-    context "with a http uri" do
-      let(:config) { build_config(:env => :test) }
-
-      it { expect(subject).to be_instance_of(Net::HTTP) }
-      it { expect(subject.proxy?).to be_falsy }
-      it { expect(subject.use_ssl?).to be_falsy }
-    end
-
-    context "with a https uri" do
-      let(:config) { build_config(:env => :production) }
-
-      it { expect(subject).to be_instance_of(Net::HTTP) }
-      it { expect(subject.proxy?).to be_falsy }
-      it { expect(subject.use_ssl?).to be_truthy }
-      it { expect(subject.verify_mode).to eq OpenSSL::SSL::VERIFY_PEER }
-      it { expect(subject.ca_file).to eq config[:ca_file_path] }
-    end
-
-    context "with a proxy" do
-      let(:config) { build_config(:options => { :http_proxy => "http://localhost:8080" }) }
-
-      it "is of Net::HTTP class" do
-        expect(subject).to be_instance_of(Net::HTTP)
-      end
-      it { expect(subject.proxy?).to be_truthy }
-      it { expect(subject.proxy_address).to eq "localhost" }
-      it { expect(subject.proxy_port).to eq 8080 }
-    end
-  end
-end

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

@@ -1,166 +0,0 @@
-describe Appsignal::Utils::Data do
-  describe ".generate" do
-    subject { Appsignal::Utils::Data.generate(body) }
-
-    context "when extension is not loaded", :extension_installation_failure do
-      around do |example|
-        Appsignal::Testing.without_testing { example.run }
-      end
-
-      context "with valid hash body" do
-        let(:body) { hash_body }
-
-        it "does not error and returns MockData class" do
-          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
-          expect(subject.to_s).to eql("{}")
-        end
-      end
-
-      context "with valid array body" do
-        let(:body) { array_body }
-
-        it "does not error and returns MockData class" do
-          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
-          expect(subject.to_s).to eql("{}")
-        end
-      end
-
-      context "with an invalid body" do
-        let(:body) { "body" }
-
-        it "raise a type error" do
-          expect do
-            subject
-          end.to raise_error TypeError
-        end
-      end
-    end
-
-    context "when extension is loaded" do
-      context "with a valid hash body" do
-        let(:body) { hash_body }
-
-        it "returns a valid Data object" do
-          is_expected.to eq Appsignal::Utils::Data.generate(body)
-          is_expected.to_not eq Appsignal::Utils::Data.generate({})
-        end
-
-        describe "#to_s" do
-          it "returns a serialized hash" do
-            # rubocop:disable Style/StringConcatenation
-            expect(subject.to_s).to eq %({"":"test",) +
-              %("1":true,) +
-              %("bar":null,) +
-              %("baz":{"arr":[1,2],"foo":"bʊr"},) +
-              %("float":1.0,) +
-              %("foo":[1,2,"three",{"foo":"bar"}],) +
-              %("int":1,) +
-              %("int61":#{1 << 61},) +
-              %("int62":#{1 << 62},) +
-              %("int63":"bigint:#{1 << 63}",) +
-              %("int64":"bigint:#{1 << 64}",) +
-              %("the":"payload"})
-            # rubocop:enable Style/StringConcatenation
-          end
-        end
-      end
-
-      context "with a valid array body" do
-        let(:body) { array_body }
-
-        it "returns a valid Data object" do
-          is_expected.to eq Appsignal::Utils::Data.generate(body)
-          is_expected.to_not eq Appsignal::Utils::Data.generate({})
-        end
-
-        describe "#to_s" do
-          it "returns a serialized array" do
-            # rubocop:disable Style/StringConcatenation, Style/RedundantStringEscape
-            expect(subject.to_s).to eq %([null,) +
-              %(true,) +
-              %(false,) +
-              %(\"string\",) +
-              %(1,) +
-              %(1.0,) +
-              %(#{1 << 61},) +
-              %(#{1 << 62},) +
-              %("bigint:#{1 << 63}",) +
-              %("bigint:#{1 << 64}",) +
-              %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
-            # rubocop:enable Style/StringConcatenation, Style/RedundantStringEscape
-          end
-        end
-      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) 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
-
-        describe "#to_s" do
-          it "returns a JSON representation in a String" do
-            # rubocop:disable Style/StringConcatenation
-            expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},) +
-              %("field_one":"aa",) +
-              %("field_three":["one","aa�"],) +
-              %("field_two":"aa�"})
-            # rubocop:enable Style/StringConcatenation
-          end
-        end
-      end
-
-      context "with an invalid body" do
-        let(:body) { "body" }
-
-        it "raises a type error" do
-          expect do
-            subject
-          end.to raise_error TypeError
-        end
-      end
-    end
-  end
-
-  def hash_body
-    {
-      "the" => "payload",
-      "int" => 1, # Fixnum
-      "int61" => 1 << 61, # Fixnum
-      "int62" => 1 << 62, # Bignum, this one still works
-      "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
-      "int64" => 1 << 64, # Bignum
-      "float" => 1.0,
-      1 => true,
-      nil => "test",
-      :foo => [1, 2, "three", { "foo" => "bar" }],
-      "bar" => nil,
-      "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
-    }
-  end
-
-  def array_body
-    [
-      nil,
-      true,
-      false,
-      "string",
-      1, # Fixnum
-      1.0, # Float
-      1 << 61, # Fixnum
-      1 << 62, # Bignum, this one still works
-      1 << 63, # Bignum, turnover point for C, too big for long
-      1 << 64, # Bignum
-      { "arr" => [1, 2, "three"], "foo" => "bʊr" }
-    ]
-  end
-end

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

@@ -1,182 +0,0 @@
-describe Appsignal::Utils::HashSanitizer do
-  let(:file) { uploaded_file }
-  let(:some_array) { [1, 2, 3] }
-  let(:some_hash) { { :a => 1, :b => 2 } }
-  let(:params) do
-    {
-      :text => "string",
-      "string" => "string key value",
-      :file => file,
-      :float => 0.0,
-      :bool_true => true,
-      :bool_false => false,
-      # Non-recursive appearances of the same array instance
-      :some_arrays => [some_array, some_array],
-      # Non-recursive appearances of the same hash instance
-      :some_hashes => { :a => some_hash, :b => some_hash },
-      :nil => nil,
-      :int => 1, # Fixnum
-      :int64 => 1 << 64, # Bignum
-      :hash => {
-        :nested_text => "string",
-        :nested_array => [
-          "something",
-          "else",
-          file,
-          {
-            :key => "value",
-            :file => file
-          }.tap do |hsh|
-            # Recursive hash-in-hash (should be [:nested_array][3][:recursive_hash])
-            hsh[:recursive_hash] = hsh
-          end
-        ].tap do |ary|
-          # Recursive array-in-array (should be [:nested_array][4])
-          ary << ary
-          # Recursive array-in-hash (should be [:nested_array][3][:recursive_array])
-          ary[3][:recursive_array] = ary
-        end
-      }.tap do |hsh|
-        # Recursive hash-in-array (should be [:nested_array][5])
-        hsh[:nested_array] << hsh
-      end
-    }
-  end
-
-  describe ".sanitize" do
-    let(:sanitized_params) { described_class.sanitize(params) }
-    subject { sanitized_params }
-
-    it "returns a sanitized Hash" do
-      expect(subject).to_not eq(params)
-      is_expected.to be_instance_of Hash
-      expect(subject[:text]).to eq("string")
-      expect(subject["string"]).to eq("string key value")
-      expect(subject[:file]).to be_instance_of String
-      expect(subject[:file]).to include "::UploadedFile"
-      expect(subject[:float]).to eq(0.0)
-      expect(subject[:bool_true]).to be(true)
-      expect(subject[:bool_false]).to be(false)
-      expect(subject[:nil]).to be_nil
-      expect(subject[:int]).to eq(1)
-      expect(subject[:int64]).to eq(1 << 64)
-      expect(subject[:some_arrays]).to eq([[1, 2, 3], [1, 2, 3]])
-      expect(subject[:some_hashes]).to eq({ :a => { :a => 1, :b => 2 },
-:b => { :a => 1, :b => 2 } })
-    end
-
-    it "does not change the original params" do
-      subject
-      expect(params[:file]).to eq(file)
-      expect(params[:hash][:nested_array][2]).to eq(file)
-    end
-
-    describe ":hash key" do
-      subject { sanitized_params[:hash] }
-
-      it "returns a sanitized Hash" do
-        expect(subject).to_not eq(params[:hash])
-        is_expected.to be_instance_of Hash
-        expect(subject[:nested_text]).to eq("string")
-      end
-
-      describe ":nested_array key" do
-        subject { sanitized_params[:hash][:nested_array] }
-
-        it "returns a sanitized Array" do
-          expect(subject).to_not eq(params[:hash][:nested_array])
-          is_expected.to be_instance_of Array
-          expect(subject[0]).to eq("something")
-          expect(subject[1]).to eq("else")
-          expect(subject[2]).to be_instance_of String
-          expect(subject[2]).to include "::UploadedFile"
-        end
-
-        describe "nested hash" do
-          subject { sanitized_params[:hash][:nested_array][3] }
-
-          it "returns a sanitized Hash" do
-            expect(subject).to_not eq(params[:hash][:nested_array][3])
-            is_expected.to be_instance_of Hash
-            expect(subject[:key]).to eq("value")
-            expect(subject[:file]).to be_instance_of String
-            expect(subject[:file]).to include "::UploadedFile"
-          end
-
-          it "replaces a recursive array" do
-            expect(subject[:recursive_array]).to eq("[RECURSIVE VALUE]")
-          end
-
-          it "replaces a recursive hash" do
-            expect(subject[:recursive_hash]).to eq("[RECURSIVE VALUE]")
-          end
-        end
-
-        describe "nested array" do
-          it "replaces a recursive array" do
-            expect(sanitized_params[:hash][:nested_array][4]).to eq("[RECURSIVE VALUE]")
-          end
-
-          it "replaces a recursive hash" do
-            expect(sanitized_params[:hash][:nested_array][5]).to eq("[RECURSIVE VALUE]")
-          end
-        end
-      end
-    end
-
-    context "with filter_keys" do
-      let(:sanitized_params) do
-        described_class.sanitize(params, %w[text hash])
-      end
-      subject { sanitized_params }
-
-      it "returns a sanitized Hash with the given keys filtered out" do
-        expect(subject).to_not eq(params)
-        expect(subject[:text]).to eq(described_class::FILTERED)
-        expect(subject[:hash]).to eq(described_class::FILTERED)
-
-        expect(subject[:file]).to be_instance_of String
-        expect(subject[:file]).to include "::UploadedFile"
-        expect(subject[:float]).to eq(0.0)
-        expect(subject[:bool_true]).to be(true)
-        expect(subject[:bool_false]).to be(false)
-        expect(subject[:nil]).to be_nil
-        expect(subject[:int]).to eq(1)
-      end
-
-      context "with strings as key filter values" do
-        let(:sanitized_params) do
-          described_class.sanitize(params, %w[string])
-        end
-
-        it "sanitizes values" do
-          expect(subject["string"]).to eq("[FILTERED]")
-        end
-      end
-
-      describe ":hash key" do
-        let(:sanitized_params) do
-          described_class.sanitize(params, %w[nested_text])
-        end
-        subject { sanitized_params[:hash] }
-
-        it "sanitizes values in nested hashes" do
-          expect(subject[:nested_text]).to eq("[FILTERED]")
-        end
-
-        describe ":nested_array" do
-          describe ":nested_hash" do
-            let(:sanitized_params) do
-              described_class.sanitize(params, %w[key])
-            end
-            subject { sanitized_params[:hash][:nested_array][3] }
-
-            it "sanitizes values in deeply nested hashes and arrays" do
-              expect(subject[:key]).to eq("[FILTERED]")
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-describe Appsignal::Utils::IntegrationLogger do
-  let(:log_stream) { std_stream }
-  let(:logs) { log_contents(log_stream) }
-  let(:logger) do
-    Appsignal::Utils::IntegrationLogger.new(log_stream).tap do |l|
-      l.formatter = logger_formatter
-    end
-  end
-
-  it "logs messages" do
-    logger.debug("debug message")
-    logger.info("info message")
-    logger.warn("warning message")
-    logger.error("error message")
-
-    expect(logs).to contains_log(:debug, "debug message")
-    expect(logs).to contains_log(:info, "info message")
-    expect(logs).to contains_log(:warn, "warning message")
-    expect(logs).to contains_log(:error, "error message")
-  end
-end