appsignal 4.0.5 → 4.0.7

data/spec/lib/appsignal/sample_data_spec.rb

@@ -1,238 +0,0 @@
-describe Appsignal::SampleData do
-  let(:data) { described_class.new(:data_key) }
-
-  describe "#add" do
-    it "sets the given value" do
-      logs =
-        capture_logs do
-          data.add(:key1 => "value 1")
-        end
-
-      expect(data.value).to eq(:key1 => "value 1")
-
-      expect(logs).to_not contains_log(
-        :error,
-        "Sample data 'data_key': Unsupported data type 'NilClass' received: nil"
-      )
-    end
-
-    it "adds the given value with the block being leading" do
-      data.add(:key1 => "value 1") { { :key2 => "value 2" } }
-
-      expect(data.value).to eq(:key2 => "value 2")
-    end
-
-    it "doesn't add nil to the data" do
-      logs =
-        capture_logs do
-          data.add([1])
-          data.add(nil)
-          data.add { nil }
-          data.add([2, 3])
-        end
-
-      expect(data.value).to eq([1, 2, 3])
-      expect(logs).to contains_log(
-        :error,
-        "Sample data 'data_key': Unsupported data type 'NilClass' received: nil"
-      )
-      expect(logs).to_not contains_log(:warn, "The sample data 'data_key' changed type")
-    end
-
-    it "merges multiple values" do
-      data.add(:key1 => "value 1")
-      data.add(:key2 => "value 2")
-
-      expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2")
-    end
-
-    it "merges only root level Hash keys" do
-      data.add(:key => { :abc => "value" })
-      data.add(:key => { :def => "value" })
-
-      expect(data.value).to eq(:key => { :def => "value" })
-    end
-
-    it "merges values from arguments and blocks" do
-      data.add(:key1 => "value 1")
-      data.add { { :key2 => "value 2" } }
-      data.add(:key3 => "value 3")
-
-      expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2", :key3 => "value 3")
-    end
-
-    it "merges array values" do
-      data.add([:first_arg])
-      data.add { [:from_block] }
-      data.add([:second_arg])
-
-      expect(data.value).to eq([:first_arg, :from_block, :second_arg])
-    end
-
-    it "overwrites the value if the new value is of a different type" do
-      data.add(:key1 => "value 1")
-      expect(data.value).to eq(:key1 => "value 1")
-
-      data.add(["abc"])
-      expect(data.value).to eq(["abc"])
-
-      logs = capture_logs { data.value }
-      expect(logs).to contains_log(
-        :warn,
-        "The sample data 'data_key' changed type from 'Hash' to 'Array'."
-      )
-    end
-
-    it "ignores invalid values" do
-      logs = capture_logs { data.add("string") }
-      expect(data.value).to be_nil
-      expect(logs).to contains_log(
-        :error,
-        "Sample data 'data_key': Unsupported data type 'String' received: \"string\""
-      )
-
-      set = Set.new
-      set.add("abc")
-      logs = capture_logs { data.add(set) }
-      expect(data.value).to be_nil
-      expect(logs).to contains_log(
-        :error,
-        "Sample data 'data_key': Unsupported data type 'Set' received: #<Set: {\"abc\"}>"
-      )
-
-      instance = Class.new
-      logs = capture_logs { data.add(instance) }
-      expect(data.value).to be_nil
-      expect(logs).to contains_log(
-        :error,
-        "Sample data 'data_key': Unsupported data type 'Class' received: #<Class:"
-      )
-    end
-
-    context "with a type specified" do
-      it "only accepts values of Hash type" do
-        data = described_class.new(:data_key, Hash)
-
-        data.add(:key1 => "value 1")
-        data.add(["abc"])
-        data.add { { :key2 => "value 2" } }
-        data.add { ["def"] }
-        data.add(:key3 => "value 3")
-
-        expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2", :key3 => "value 3")
-      end
-
-      it "only accepts values of Array type" do
-        data = described_class.new(:data_key, Array)
-
-        data.add(:key1 => "value 1")
-        data.add(["abc"])
-        data.add { { :key2 => "value 2" } }
-        data.add { ["def"] }
-        data.add(:key3 => "value 3")
-
-        expect(data.value).to eq(["abc", "def"])
-      end
-    end
-  end
-
-  describe "#value" do
-    it "caches the block value after calling it once" do
-      Appsignal::Testing.store[:block_call] = 0
-      data.add do
-        Appsignal::Testing.store[:block_call] += 1
-        { :key => "value" }
-      end
-
-      expect(data.value).to eq(:key => "value")
-      data.value
-
-      expect(Appsignal::Testing.store[:block_call]).to eq(1)
-    end
-  end
-
-  describe "#value?" do
-    it "returns true when value is set" do
-      data.add(["abc"])
-      expect(data.value?).to be_truthy
-    end
-
-    it "returns true when value is set with a block" do
-      data.add { ["abc"] }
-      expect(data.value?).to be_truthy
-    end
-
-    it "returns false when the value is not set" do
-      expect(data.value?).to be_falsey
-    end
-  end
-
-  describe "#set_empty_value!" do
-    it "clears the set values" do
-      data.add(["abc"])
-      data.add(["def"])
-      data.set_empty_value!
-
-      expect(data.value).to be_nil
-    end
-
-    it "allows values to be added afterwards" do
-      data.add(["abc"])
-      data.set_empty_value!
-
-      expect(data.value).to be_nil
-
-      data.add(["def"])
-      expect(data.value).to eq(["def"])
-    end
-  end
-
-  describe "#cleared?" do
-    it "returns false if not cleared" do
-      expect(data.empty?).to be(false)
-    end
-
-    it "returns true if cleared" do
-      data.set_empty_value!
-
-      expect(data.empty?).to be(true)
-    end
-
-    it "returns false if cleared and then new values were added" do
-      data.set_empty_value!
-      data.add(["abc"])
-
-      expect(data.empty?).to be(false)
-    end
-  end
-
-  describe "#duplicate" do
-    it "duplicates the internal Hash state without modifying the original" do
-      data = described_class.new(:my_key, Hash)
-      data.add(:abc => :value)
-
-      duplicate = data.dup
-      duplicate.add(:def => :value)
-
-      expect(data.value).to eq(:abc => :value)
-      expect(duplicate.value).to eq(:abc => :value, :def => :value)
-
-      expect(duplicate.instance_variable_get(:@key)).to eq(:my_key)
-      expect(duplicate.instance_variable_get(:@accepted_type)).to eq(Hash)
-    end
-
-    it "duplicates the internal Array state without modifying the original" do
-      data = described_class.new(:my_key, Array)
-      data.add([:abc])
-
-      duplicate = data.dup
-      duplicate.add([:def])
-
-      expect(data.value).to eq([:abc])
-      expect(duplicate.value).to eq([:abc, :def])
-
-      expect(duplicate.instance_variable_get(:@key)).to eq(:my_key)
-      expect(duplicate.instance_variable_get(:@accepted_type)).to eq(Array)
-    end
-  end
-end

data/spec/lib/appsignal/span_spec.rb

@@ -1,141 +0,0 @@
-require "appsignal/span"
-
-describe Appsignal::Span do
-  before { start_agent }
-
-  let(:namespace) { "web" }
-  let(:root) { Appsignal::Span.new(namespace) }
-
-  describe "creating a span" do
-    it "creates an empty span" do
-      expect(root.to_h["namespace"]).to eq "web"
-      expect(root.to_h["trace_id"].length).to eq 16
-      expect(root.to_h["span_id"].length).to eq 8
-      expect(root.to_h["parent_span_id"]).to be_empty
-      expect(root.to_h["name"]).to be_empty
-      expect(root.to_h["start_time_seconds"]).to be > 1_600_000_000
-      expect(root.to_h["start_time_nanoseconds"]).to be_kind_of(Numeric)
-      expect(root.to_h["closed"]).to be false
-    end
-  end
-
-  describe "#child" do
-    let(:child) { root.child }
-
-    it "creates a child span" do
-      expect(child.to_h["namespace"]).to be_empty
-      expect(child.to_h["trace_id"].length).to eq 16
-      expect(child.to_h["span_id"].length).to eq 8
-      expect(child.to_h["parent_span_id"]).to eq root.to_h["span_id"]
-      expect(child.to_h["name"]).to be_empty
-      expect(root.to_h["start_time_seconds"]).to be > 1_600_000_000
-      expect(root.to_h["start_time_nanoseconds"]).to be_kind_of(Numeric)
-      expect(child.to_h["closed"]).to be false
-    end
-  end
-
-  describe "#add_error" do
-    it "adds an error" do
-      begin
-        raise "Error"
-      rescue => error
-        root.add_error(error)
-      end
-
-      error = root.to_h["error"]
-      expect(error["name"]).to eq "RuntimeError"
-      expect(error["message"]).to eq "Error"
-      expect(error["backtrace_json"]).not_to be_empty
-    end
-  end
-
-  describe "set_sample_data" do
-    it "sets sample data" do
-      root.set_sample_data(:params, "key" => "value")
-
-      sample_data = root.to_h["sample_data"]
-      expect(sample_data["params"]).to eq "{\"key\":\"value\"}"
-    end
-  end
-
-  describe "#name=" do
-    it "sets the name" do
-      root.name = "Span name"
-
-      expect(root.to_h["name"]).to eq "Span name"
-    end
-  end
-
-  describe "#[]=" do
-    let(:attributes) { root.to_h["attributes"] }
-
-    it "sets a string attribute" do
-      root["string"] = "attribute"
-
-      expect(attributes["string"]).to eq "attribute"
-    end
-
-    it "sets an integer attribute" do
-      root["integer"] = 1001
-
-      expect(attributes["integer"]).to eq 1001
-    end
-
-    it "sets a bigint attribute" do
-      root["bigint"] = 1 << 64
-
-      expect(attributes["bigint"]).to eq "bigint:#{1 << 64}"
-    end
-
-    it "sets a boolean attribute" do
-      root["true"] = true
-      root["false"] = false
-
-      expect(attributes["true"]).to eq true
-      expect(attributes["false"]).to eq false
-    end
-
-    it "sets a float attribute" do
-      root["float"] = 10.01
-
-      expect(attributes["float"]).to eq 10.01
-    end
-
-    it "raises an error for other types" do
-      expect do
-        root["something"] = Object.new
-      end.to raise_error TypeError
-    end
-  end
-
-  describe "#instrument" do
-    it "closes the span after yielding" do
-      root.instrument do
-        # Nothing happening
-      end
-      expect(root.closed?).to eq true
-    end
-
-    context "with an error raised in the passed block" do
-      it "closes the span after yielding" do
-        expect do
-          root.instrument do
-            raise ExampleException, "foo"
-          end
-        end.to raise_error(ExampleException, "foo")
-        expect(root.closed?).to eq true
-      end
-    end
-  end
-
-  describe "#close" do
-    it "closes a span" do
-      expect(root.closed?).to eq false
-
-      root.close
-
-      expect(root.to_h).to be_nil
-      expect(root.closed?).to eq true
-    end
-  end
-end

data/spec/lib/appsignal/system_spec.rb

@@ -1,126 +0,0 @@
-require "appsignal/system"
-
-describe Appsignal::System do
-  describe ".heroku?" do
-    subject { described_class.heroku? }
-
-    context "when on Heroku" do
-      around { |example| recognize_as_heroku { example.run } }
-
-      it "returns true" do
-        is_expected.to eq(true)
-      end
-    end
-
-    context "when not on Heroku" do
-      it "returns false" do
-        is_expected.to eq(false)
-      end
-    end
-  end
-
-  describe ".agent_platform" do
-    let(:os) { "linux-gnu" }
-    let(:ldd_output) { "" }
-    before do
-      allow(described_class).to receive(:ldd_version_output).and_return(ldd_output)
-      allow(RbConfig::CONFIG).to receive(:[])
-      allow(RbConfig::CONFIG).to receive(:[]).with("host_os").and_return(os)
-    end
-    subject { described_class.agent_platform }
-
-    context "when the system detection doesn't work" do
-      it "returns the libc build" do
-        is_expected.to eq("linux")
-      end
-    end
-
-    context "when using the APPSIGNAL_BUILD_FOR_MUSL env var" do
-      it "returns the musl build" do
-        ENV["APPSIGNAL_BUILD_FOR_MUSL"] = "1"
-        is_expected.to eq("linux-musl")
-        ENV.delete("APPSIGNAL_BUILD_FOR_MUSL")
-      end
-    end
-
-    context "when using the APPSIGNAL_BUILD_FOR_LINUX_ARM env var" do
-      it "returns the linux build" do
-        ENV["APPSIGNAL_BUILD_FOR_LINUX_ARM"] = "1"
-        is_expected.to eq("linux")
-        ENV.delete("APPSIGNAL_BUILD_FOR_LINUX_ARM")
-      end
-    end
-
-    context "when on a musl system" do
-      let(:ldd_output) { "musl libc (x86_64)\nVersion 1.1.16" }
-
-      it "returns the musl build" do
-        is_expected.to eq("linux-musl")
-      end
-    end
-
-    context "when on a libc system" do
-      let(:ldd_output) { "ldd (Debian GLIBC 2.15-18+deb8u7) 2.15" }
-
-      it "returns the libc build" do
-        is_expected.to eq("linux")
-      end
-
-      context "when on an old libc system" do
-        let(:ldd_output) { "ldd (Debian GLIBC 2.14-18+deb8u7) 2.14" }
-
-        it "returns the musl build" do
-          is_expected.to eq("linux-musl")
-        end
-      end
-
-      context "when on a very old libc system" do
-        let(:ldd_output) { "ldd (Debian GLIBC 2.5-18+deb8u7) 2.5" }
-
-        it "returns the musl build" do
-          is_expected.to eq("linux-musl")
-        end
-      end
-    end
-
-    context "when on macOS" do
-      let(:os) { "darwin16.7.0" }
-      let(:ldd_output) { "ldd: command not found" }
-
-      it "returns the darwin build" do
-        is_expected.to eq("darwin")
-      end
-    end
-
-    context "when on FreeBSD" do
-      let(:os) { "freebsd11" }
-      let(:ldd_output) { "ldd: illegal option -- -" }
-
-      it "returns the FreeBSD build" do
-        is_expected.to eq("freebsd")
-      end
-    end
-  end
-
-  describe ".agent_architecture" do
-    let(:architecture) { "x86_64" }
-    let(:ldd_output) { "" }
-    before do
-      allow(RbConfig::CONFIG).to receive(:[])
-      allow(RbConfig::CONFIG).to receive(:[]).with("host_cpu").and_return(architecture)
-    end
-    subject { described_class.agent_architecture }
-
-    it "returns the host CPU value" do
-      is_expected.to eq(architecture)
-    end
-
-    context "when using the APPSIGNAL_BUILD_FOR_LINUX_ARM env var" do
-      it "returns ARM 64 bit" do
-        ENV["APPSIGNAL_BUILD_FOR_LINUX_ARM"] = "1"
-        is_expected.to eq("aarch64")
-        ENV.delete("APPSIGNAL_BUILD_FOR_LINUX_ARM")
-      end
-    end
-  end
-end