appsignal 4.0.5 → 4.0.7

data/spec/lib/appsignal/logger_spec.rb

@@ -1,205 +0,0 @@
-describe Appsignal::Logger do
-  let(:log_stream) { StringIO.new }
-  let(:logs) { log_contents(log_stream) }
-  let(:logger) { Appsignal::Logger.new("group", :level => ::Logger::DEBUG) }
-
-  before do
-    Appsignal.internal_logger = test_logger(log_stream)
-  end
-
-  it "should not create a logger with a nil group" do
-    expect do
-      Appsignal::Logger.new(nil)
-    end.to raise_error(TypeError)
-  end
-
-  describe "#add" do
-    it "should log with a level and message" do
-      expect(Appsignal::Extension).to receive(:log)
-        .with("group", 3, 0, "Log message", instance_of(Appsignal::Extension::Data))
-      logger.add(::Logger::INFO, "Log message")
-    end
-
-    it "does not log a message that's not a String" do
-      expect(Appsignal::Extension).to_not receive(:log)
-      logger.add(::Logger::INFO, 123)
-      logger.add(::Logger::INFO, {})
-      logger.add(::Logger::INFO, [])
-      expect(logs)
-        .to contains_log(:warn, "Logger message was ignored, because it was not a String: 123")
-      expect(logs)
-        .to contains_log(:warn, "Logger message was ignored, because it was not a String: []")
-      expect(logs)
-        .to contains_log(:warn, "Logger message was ignored, because it was not a String: {}")
-    end
-
-    it "should log with a block" do
-      expect(Appsignal::Extension).to receive(:log)
-        .with("group", 3, 0, "Log message", instance_of(Appsignal::Extension::Data))
-      logger.add(::Logger::INFO) do
-        "Log message"
-      end
-    end
-
-    it "should log with a level, message and group" do
-      expect(Appsignal::Extension).to receive(:log)
-        .with("other_group", 3, 0, "Log message", instance_of(Appsignal::Extension::Data))
-      logger.add(::Logger::INFO, "Log message", "other_group")
-    end
-
-    it "should log when using `group` for the log message" do
-      expect(Appsignal::Extension).to receive(:log)
-        .with("group", 3, 0, "Log message", instance_of(Appsignal::Extension::Data))
-      logger.add(::Logger::INFO, nil, "Log message")
-    end
-
-    context "with info log level" do
-      let(:logger) { Appsignal::Logger.new("group", :level => ::Logger::INFO) }
-
-      it "should skip logging if the level is too low" do
-        expect(Appsignal::Extension).not_to receive(:log)
-        logger.add(::Logger::DEBUG, "Log message")
-      end
-    end
-
-    context "with a format set" do
-      let(:logger) { Appsignal::Logger.new("group", :format => Appsignal::Logger::LOGFMT) }
-
-      it "should log and pass the format flag" do
-        expect(Appsignal::Extension).to receive(:log)
-          .with("group", 3, 1, "Log message", instance_of(Appsignal::Extension::Data))
-        logger.add(::Logger::INFO, "Log message")
-      end
-    end
-
-    context "with a formatter set" do
-      before do
-        logger.formatter = proc do |_level, _timestamp, _appname, message|
-          "formatted: '#{message}'"
-        end
-      end
-
-      it "should log with a level, message and group" do
-        expect(Appsignal::Extension).to receive(:log).with(
-          "other_group",
-          3,
-          0,
-          "formatted: 'Log message'",
-          instance_of(Appsignal::Extension::Data)
-        )
-        logger.add(::Logger::INFO, "Log message", "other_group")
-      end
-    end
-  end
-
-  describe "#silence" do
-    it "calls the given block" do
-      num = 1
-
-      logger.silence do
-        num += 1
-      end
-
-      expect(num).to eq(2)
-      expect(Appsignal::Extension).not_to receive(:log)
-    end
-  end
-
-  [
-    ["debug", 2, ::Logger::INFO],
-    ["info", 3, ::Logger::WARN],
-    ["warn", 5, ::Logger::ERROR],
-    ["error", 6, ::Logger::FATAL],
-    ["fatal", 7, nil]
-  ].each do |method|
-    describe "##{method[0]}" do
-      it "should log with a message" do
-        expect(Appsignal::Utils::Data).to receive(:generate)
-          .with({ :attribute => "value" })
-          .and_call_original
-        expect(Appsignal::Extension).to receive(:log)
-          .with("group", method[1], 0, "Log message", instance_of(Appsignal::Extension::Data))
-
-        logger.send(method[0], "Log message", :attribute => "value")
-      end
-
-      it "should log with a block" do
-        expect(Appsignal::Utils::Data).to receive(:generate)
-          .with({})
-          .and_call_original
-        expect(Appsignal::Extension).to receive(:log)
-          .with("group", method[1], 0, "Log message", instance_of(Appsignal::Extension::Data))
-
-        logger.send(method[0]) do
-          "Log message"
-        end
-      end
-
-      it "should return with a nil message" do
-        expect(Appsignal::Extension).not_to receive(:log)
-        logger.send(method[0])
-      end
-
-      if method[2]
-        context "with a lower log level" do
-          let(:logger) { Appsignal::Logger.new("group", :level => method[2]) }
-
-          it "should skip logging if the level is too low" do
-            expect(Appsignal::Extension).not_to receive(:log)
-            logger.send(method[0], "Log message")
-          end
-        end
-      end
-
-      context "with a formatter set" do
-        before do
-          Timecop.freeze(Time.local(2023))
-          logger.formatter = logger.formatter = proc do |_level, timestamp, _appname, message|
-            # This line replicates the behaviour of the Ruby default Logger::Formatter
-            # which expects a timestamp object as a second argument
-            # https://github.com/ruby/ruby/blob/master/lib/logger/formatter.rb#L15-L17
-            time = timestamp.strftime("%Y-%m-%dT%H:%M:%S.%6N")
-            "formatted: #{time} '#{message}'"
-          end
-        end
-
-        after do
-          Timecop.return
-        end
-
-        it "should log with a level, message and group" do
-          expect(Appsignal::Extension).to receive(:log)
-            .with(
-              "group",
-              method[1],
-              0,
-              "formatted: 2023-01-01T00:00:00.000000 'Log message'",
-              instance_of(Appsignal::Extension::Data)
-            )
-          logger.send(method[0], "Log message")
-        end
-      end
-    end
-  end
-
-  describe "#error with exception object" do
-    it "logs the exception class and its message" do
-      error =
-        begin
-          raise ExampleStandardError, "oh no!"
-        rescue => e
-          # This makes the exception include a backtrace, so we can assert it's NOT included
-          e
-        end
-      expect(Appsignal::Extension).to receive(:log)
-        .with(
-          "group",
-          6,
-          0,
-          "ExampleStandardError: oh no!",
-          instance_of(Appsignal::Extension::Data)
-        )
-      logger.error(error)
-    end
-  end
-end

data/spec/lib/appsignal/marker_spec.rb

@@ -1,51 +0,0 @@
-describe Appsignal::Marker do
-  let(:config) { build_config }
-  let(:marker) do
-    described_class.new(
-      {
-        :revision => "503ce0923ed177a3ce000005",
-        :repository => "main",
-        :user => "batman",
-        :rails_env => "production"
-      },
-      config
-    )
-  end
-  let(:out_stream) { std_stream }
-  let(:output) { out_stream.read }
-
-  describe "#transmit" do
-    def stub_marker_request
-      stub_api_request config, "markers", marker.marker_data
-    end
-
-    def run
-      capture_stdout(out_stream) { marker.transmit }
-    end
-
-    context "when request is valid" do
-      before { stub_marker_request.to_return(:status => 200) }
-
-      it "outputs success" do
-        run
-        expect(output).to include \
-          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
-          "AppSignal has been notified of this deploy!"
-      end
-    end
-
-    context "when request is invalid" do
-      before { stub_marker_request.to_return(:status => 500) }
-
-      it "outputs failure" do
-        run
-        expect(output).to include \
-          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
-          "Something went wrong while trying to notify AppSignal: 500 at " \
-            "#{config[:endpoint]}/1/markers"
-        expect(output).to_not include \
-          "AppSignal has been notified of this deploy!"
-      end
-    end
-  end
-end

data/spec/lib/appsignal/probes/gvl_spec.rb

@@ -1,164 +0,0 @@
-describe Appsignal::Probes::GvlProbe do
-  let(:appsignal_mock) { AppsignalMock.new(:hostname => hostname) }
-  let(:probe) { described_class.new(:appsignal => appsignal_mock, :gvl_tools => FakeGVLTools) }
-
-  let(:hostname) { "some-host" }
-
-  around do |example|
-    real_program_name = $PROGRAM_NAME
-    example.run
-  ensure
-    $PROGRAM_NAME = real_program_name
-  end
-
-  def gauges_for(metric)
-    gauges = appsignal_mock.gauges.select do |gauge|
-      gauge[0] == metric
-    end
-
-    gauges.map do |gauge|
-      gauge.drop(1)
-    end
-  end
-
-  after { FakeGVLTools.reset }
-
-  it "gauges the global timer delta" do
-    FakeGVLTools::GlobalTimer.monotonic_time = 100_000_000
-    probe.call
-
-    expect(gauges_for("gvl_global_timer")).to be_empty
-
-    FakeGVLTools::GlobalTimer.monotonic_time = 300_000_000
-    probe.call
-
-    expect(gauges_for("gvl_global_timer")).to eq [
-      [200, {
-        :hostname => hostname,
-        :process_name => "rspec",
-        :process_id => Process.pid
-      }],
-      [200, { :hostname => hostname }]
-    ]
-  end
-
-  context "when the delta is negative" do
-    it "does not gauge the global timer delta" do
-      FakeGVLTools::GlobalTimer.monotonic_time = 300_000_000
-      probe.call
-
-      expect(gauges_for("gvl_global_timer")).to be_empty
-
-      FakeGVLTools::GlobalTimer.monotonic_time = 0
-      probe.call
-
-      expect(gauges_for("gvl_global_timer")).to be_empty
-    end
-  end
-
-  context "when the delta is zero" do
-    it "does not gauge the global timer delta" do
-      FakeGVLTools::GlobalTimer.monotonic_time = 300_000_000
-      probe.call
-
-      expect(gauges_for("gvl_global_timer")).to be_empty
-
-      probe.call
-
-      expect(gauges_for("gvl_global_timer")).to be_empty
-    end
-  end
-
-  context "when the waiting threads count is enabled" do
-    before do
-      FakeGVLTools::WaitingThreads.enabled = true
-    end
-
-    it "gauges the waiting threads count" do
-      FakeGVLTools::WaitingThreads.count = 3
-      probe.call
-
-      expect(gauges_for("gvl_waiting_threads")).to eq [
-        [3, {
-          :hostname => hostname,
-          :process_name => "rspec",
-          :process_id => Process.pid
-        }],
-        [3, { :hostname => hostname }]
-      ]
-    end
-  end
-
-  context "when the waiting threads count is disabled" do
-    before do
-      FakeGVLTools::WaitingThreads.enabled = false
-    end
-
-    it "does not gauge the waiting threads count" do
-      FakeGVLTools::WaitingThreads.count = 3
-      probe.call
-
-      expect(gauges_for("gvl_waiting_threads")).to be_empty
-    end
-  end
-
-  context "when the process name is a custom value" do
-    before do
-      FakeGVLTools::WaitingThreads.enabled = true
-    end
-
-    it "uses only the first word as the process name" do
-      $PROGRAM_NAME = "sidekiq 7.1.6 app [0 of 5 busy]"
-      probe.call
-
-      expect(gauges_for("gvl_waiting_threads")).to eq [
-        [0, {
-          :hostname => hostname,
-          :process_name => "sidekiq",
-          :process_id => Process.pid
-        }],
-        [0, { :hostname => hostname }]
-      ]
-    end
-  end
-
-  context "when the process name is a path" do
-    before do
-      FakeGVLTools::WaitingThreads.enabled = true
-    end
-
-    it "uses only the binary name as the process name" do
-      $PROGRAM_NAME = "/foo/folder with spaces/bin/rails"
-      probe.call
-
-      expect(gauges_for("gvl_waiting_threads")).to eq [
-        [0, {
-          :hostname => hostname,
-          :process_name => "rails",
-          :process_id => Process.pid
-        }],
-        [0, { :hostname => hostname }]
-      ]
-    end
-  end
-
-  context "when the process name is an empty string" do
-    before do
-      FakeGVLTools::WaitingThreads.enabled = true
-    end
-
-    it "uses [unknown process] as the process name" do
-      $PROGRAM_NAME = ""
-      probe.call
-
-      expect(gauges_for("gvl_waiting_threads")).to eq [
-        [0, {
-          :hostname => hostname,
-          :process_name => "[unknown process]",
-          :process_id => Process.pid
-        }],
-        [0, { :hostname => hostname }]
-      ]
-    end
-  end
-end

data/spec/lib/appsignal/probes/mri_spec.rb

@@ -1,162 +0,0 @@
-describe Appsignal::Probes::MriProbe do
-  let(:appsignal_mock) { AppsignalMock.new(:hostname => hostname) }
-  let(:gc_profiler_mock) { instance_double("Appsignal::GarbageCollectionProfiler") }
-  let(:probe) do
-    described_class.new(:appsignal => appsignal_mock, :gc_profiler => gc_profiler_mock)
-  end
-
-  describe ".dependencies_present?" do
-    if DependencyHelper.running_jruby?
-      it "should not be present" do
-        expect(described_class.dependencies_present?).to be_falsy
-      end
-    else
-      it "should be present" do
-        expect(described_class.dependencies_present?).to be_truthy
-      end
-    end
-  end
-
-  unless DependencyHelper.running_jruby?
-    describe "#call" do
-      let(:hostname) { nil }
-      before do
-        allow(gc_profiler_mock).to receive(:total_time)
-        allow(GC::Profiler).to receive(:enabled?).and_return(true)
-      end
-
-      it "should track vm cache metrics" do
-        probe.call
-        if DependencyHelper.ruby_3_2_or_newer?
-          expect_gauge_value("ruby_vm", :tags => { :metric => :constant_cache_invalidations })
-          expect_gauge_value("ruby_vm", :tags => { :metric => :constant_cache_misses })
-        else
-          expect_gauge_value("ruby_vm", :tags => { :metric => :class_serial })
-          expect_gauge_value("ruby_vm", :tags => { :metric => :global_constant_state })
-        end
-      end
-
-      it "tracks thread counts" do
-        probe.call
-        expect_gauge_value("thread_count")
-      end
-
-      it "tracks GC time between measurements" do
-        expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15)
-        probe.call
-        probe.call
-        expect_gauge_value("gc_time", 5)
-      end
-
-      context "when GC total time overflows" do
-        it "skips one report" do
-          expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15, 0, 10)
-          probe.call # Normal call, create a cache
-          probe.call # Report delta value based on cached value
-          probe.call # The value overflows and reports no value. Then stores 0 in the cache
-          probe.call # Report new value based on cache of 0
-          expect_gauges([["gc_time", 5], ["gc_time", 10]])
-        end
-      end
-
-      context "when GC profiling is disabled" do
-        it "does not report a gc_time metric" do
-          allow(GC::Profiler).to receive(:enabled?).and_return(false)
-          expect(gc_profiler_mock).to_not receive(:total_time)
-          probe.call # Normal call, create a cache
-          probe.call # Report delta value based on cached value
-          metrics = appsignal_mock.gauges.map { |(key)| key }
-          expect(metrics).to_not include("gc_time")
-        end
-
-        it "does not report a gc_time metric while temporarily disabled" do
-          # While enabled
-          allow(GC::Profiler).to receive(:enabled?).and_return(true)
-          expect(gc_profiler_mock).to receive(:total_time).and_return(10, 15)
-          probe.call # Normal call, create a cache
-          probe.call # Report delta value based on cached value
-          expect_gauges([["gc_time", 5]])
-
-          # While disabled
-          allow(GC::Profiler).to receive(:enabled?).and_return(false)
-          probe.call # Call twice to make sure any caches resets wouldn't mess up the assertion
-          probe.call
-          # Does not include any newly reported metrics
-          expect_gauges([["gc_time", 5]])
-
-          # When enabled after being disabled for a while, it only reports the
-          # newly reported time since it was renabled
-          allow(GC::Profiler).to receive(:enabled?).and_return(true)
-          expect(gc_profiler_mock).to receive(:total_time).and_return(25)
-          probe.call
-          expect_gauges([["gc_time", 5], ["gc_time", 10]])
-        end
-      end
-
-      it "tracks GC run count" do
-        expect(GC).to receive(:count).and_return(10, 15)
-        expect(GC).to receive(:stat).and_return(
-          { :minor_gc_count => 10, :major_gc_count => 10 },
-          :minor_gc_count => 16, :major_gc_count => 17
-        )
-        probe.call
-        probe.call
-        expect_gauge_value("gc_count", 5, :tags => { :metric => :gc_count })
-        expect_gauge_value("gc_count", 6, :tags => { :metric => :minor_gc_count })
-        expect_gauge_value("gc_count", 7, :tags => { :metric => :major_gc_count })
-      end
-
-      it "tracks object allocation" do
-        expect(GC).to receive(:stat).and_return(
-          { :total_allocated_objects => 10 },
-          :total_allocated_objects => 15
-        )
-        # Only tracks delta value so the needs to be called twice
-        probe.call
-        probe.call
-        expect_gauge_value("allocated_objects", 5)
-      end
-
-      it "tracks heap slots" do
-        probe.call
-        expect_gauge_value("heap_slots", :tags => { :metric => :heap_live })
-        expect_gauge_value("heap_slots", :tags => { :metric => :heap_free })
-      end
-
-      context "with custom hostname" do
-        let(:hostname) { "my hostname" }
-
-        it "reports custom hostname tag value" do
-          probe.call
-          expect_gauge_value("heap_slots",
-            :tags => { :metric => :heap_live, :hostname => hostname })
-        end
-      end
-    end
-  end
-
-  def expect_gauge_value(expected_key, expected_value = nil, tags: {})
-    expected_tags = { :hostname => Socket.gethostname }.merge(tags)
-    expect(appsignal_mock.gauges).to satisfy do |gauges|
-      gauges.any? do |distribution_value|
-        key, value, tags = distribution_value
-        next unless key == expected_key
-        next unless expected_value ? expected_value == value : !value.nil?
-        next unless tags == expected_tags
-
-        true
-      end
-    end
-  end
-
-  def expect_gauges(expected_metrics)
-    default_tags = { :hostname => Socket.gethostname }
-    keys = expected_metrics.map { |(key)| key }
-    metrics = expected_metrics.map do |metric|
-      key, value, tags = metric
-      [key, value, default_tags.merge(tags || {})]
-    end
-    found_gauges = appsignal_mock.gauges.select { |(key)| keys.include? key }
-    expect(found_gauges).to eq(metrics)
-  end
-end