appsignal 3.12.6 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d54d86a604df3df8944cf99dcd63dfe9b337c829543f5d80ce5f6d507ff80dd9
-  data.tar.gz: 39137b4064d8cd060ef32ce59ca7fe1e66066179673d44ef099af149908feb66
+  metadata.gz: 3908c76b33dae84dfbaaa42896c709c8ceaf8443dd3855c4811e660fd9da5df0
+  data.tar.gz: a5be1a3498ff49fe1e6de1d09abe81bb4d2ce2a5cc44a69e6fa45ebe9b9d8496
 SHA512:
-  metadata.gz: e4073b5455f88773ea180fecd94bf79878d845241d2b614a5c3cf7d3485d9ea300962c838721f44b5ebeeb2cb8ebe9593056d74d0072f22a515ed8b075022740
-  data.tar.gz: 666e8ff6f6ceb7526c40be3b6cd6b8082209181644fe2538ca3a587b2299a71330210dfaea59656075707a112addbf8f5e96cce224f24db7afb5bf10048812db
+  metadata.gz: 98b58eda188a7abce65a74ee3a8dbf3b7c59f6f7c9af28c7cc18181942d7ac9a886f5648f4425af78417d475739172b0ef925851f06307ba2e586d52d9763077
+  data.tar.gz: 8311cc2b6c88447565c87cc231c50e3aa0640905cef72f400cb1620057ae22ef779da497dac76287ec9404957684fe838fd6c6471d9fcc5081b5cde94e747f05

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.13.0
+
+_Published on 2024-08-14._
+
+### Changed
+
+- Remove the HTTP gem's exception handling. Errors from the HTTP gem will no longer always be reported. The error will be reported only when an HTTP request is made in an instrumented context. This gives applications the opportunity to add their own custom exception handling.
+
+  ```ruby
+  begin
+    HTTP.get("https://appsignal.com/error")
+  rescue => error
+    # Either handle the error or report it to AppSignal
+  end
+  ```
+
+  (minor [2a452ff0](https://github.com/appsignal/appsignal-ruby/commit/2a452ff07e0b0938b1623fa8846af6ef37917ec2))
+- Rename heartbeats to cron check-ins. Calls to `Appsignal.heartbeat` and `Appsignal::Heartbeat` should be replaced with calls to `Appsignal::CheckIn.cron` and `Appsignal::CheckIn::Cron`, for example:
+
+  ```ruby
+  # Before
+  Appsignal.heartbeat("do_something") do
+    do_something
+  end
+
+  # After
+  Appsignal::CheckIn.cron("do_something") do
+    do_something
+  end
+  ```
+
+  (patch [2f686cd0](https://github.com/appsignal/appsignal-ruby/commit/2f686cd00d5daa6e0854a8cacfe0e874a3a7c146))
+
+### Deprecated
+
+- Calls to `Appsignal.heartbeat` and `Appsignal::Heartbeat` will emit a deprecation warning. (patch [2f686cd0](https://github.com/appsignal/appsignal-ruby/commit/2f686cd00d5daa6e0854a8cacfe0e874a3a7c146))
+
 ## 3.12.6
 
 _Published on 2024-08-05._
@@ -18,6 +55,7 @@ _Published on 2024-08-05._
     raise "some error"
   end
 
+  # After
   begin
     raise "some error"
   rescue => error

data/lib/appsignal/check_in/cron.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module CheckIn
+    class Cron
+      class << self
+        # @api private
+        def transmitter
+          @transmitter ||= Appsignal::Transmitter.new(
+            "#{Appsignal.config[:logging_endpoint]}/check_ins/json"
+          )
+        end
+
+        def emit_initializer_deprecation_warning
+          return if @initializer_deprecation_warning_emitted
+
+          callers = caller
+          Appsignal::Utils::StdoutAndLoggerMessage.warning(
+            "Passing a `name` keyword argument to `Appsignal::CheckIn::Cron.new` is deprecated. " \
+              "Please use the `identifier` keyword argument instead, " \
+              "in the following file and elsewhere, to remove this message.\n#{callers[2]}"
+          )
+          @initializer_deprecation_warning_emitted = true
+        end
+      end
+
+      # @api private
+      attr_reader :identifier, :digest
+
+      def initialize(identifier: nil, name: nil)
+        @identifier = identifier || name || raise(ArgumentError, "missing keyword: :identifier")
+        Cron.emit_initializer_deprecation_warning unless name.nil?
+        @digest = SecureRandom.hex(8)
+      end
+
+      def start
+        transmit_event("start")
+      end
+
+      def finish
+        transmit_event("finish")
+      end
+
+      private
+
+      def event(kind)
+        {
+          :identifier => @identifier,
+          :digest => @digest,
+          :kind => kind,
+          :timestamp => Time.now.utc.to_i,
+          :check_in_type => "cron"
+        }
+      end
+
+      def transmit_event(kind)
+        unless Appsignal.active?
+          Appsignal.internal_logger.debug(
+            "AppSignal not active, not transmitting cron check-in event"
+          )
+          return
+        end
+
+        response = self.class.transmitter.transmit(event(kind))
+
+        if response.code.to_i >= 200 && response.code.to_i < 300
+          Appsignal.internal_logger.debug(
+            "Transmitted cron check-in `#{identifier}` (#{digest}) #{kind} event"
+          )
+        else
+          Appsignal.internal_logger.error(
+            "Failed to transmit cron check-in #{kind} event: status code was #{response.code}"
+          )
+        end
+      rescue => e
+        Appsignal.internal_logger.error("Failed to transmit cron check-in #{kind} event: #{e}")
+      end
+    end
+  end
+end

data/lib/appsignal/check_in.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module CheckIn
+    class << self
+      # Track cron check-ins.
+      #
+      # Track the execution of certain processes by sending a cron check-in.
+      #
+      # To track the duration of a piece of code, pass a block to {.cron}
+      # to report both when the process starts, and when it finishes.
+      #
+      # If an exception is raised within the block, the finish event will not
+      # be reported, triggering a notification about the missing cron check-in.
+      # The exception will bubble outside of the cron check-in block.
+      #
+      # @example Send a cron check-in
+      #   Appsignal::CheckIn.cron("send_invoices")
+      #
+      # @example Send a cron check-in with duration
+      #   Appsignal::CheckIn.cron("send_invoices") do
+      #     # your code
+      #   end
+      #
+      # @param name [String] name of the cron check-in to report.
+      # @yield the block to monitor.
+      # @return [void]
+      # @since 3.13.0
+      # @see https://docs.appsignal.com/check-ins/cron
+      def cron(identifier)
+        cron = Appsignal::CheckIn::Cron.new(:identifier => identifier)
+        output = nil
+
+        if block_given?
+          cron.start
+          output = yield
+        end
+
+        cron.finish
+        output
+      end
+    end
+  end
+end
+
+require "appsignal/check_in/cron"

data/lib/appsignal/helpers/heartbeat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Helpers
+    module Heartbeat
+      # @deprecated Use {Appsignal::CheckIn.cron} instead.
+      def heartbeat(name, &block)
+        unless @heartbeat_helper_deprecation_warning_emitted
+          callers = caller
+          Appsignal::Utils::StdoutAndLoggerMessage.warning \
+            "The helper Appsignal.heartbeat has been deprecated. " \
+              "Please update the helper call to Appsignal::CheckIn.cron " \
+              "in the following file and elsewhere to remove this message.\n#{callers.first}"
+          @heartbeat_helper_deprecation_warning_emitted = true
+        end
+        Appsignal::CheckIn.cron(name, &block)
+      end
+    end
+  end
+end

data/lib/appsignal/helpers/instrumentation.rb

@@ -300,7 +300,10 @@ module Appsignal
       # @see .send_error
       # @see https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html
       #   AppSignal integration guide
+      # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
+      #   Exception handling guide
       #
+      # @deprecated Use `rescue => error` with {.report_error} instead.
       # @param tags [Hash, nil]
       # @param namespace [String] the namespace for this error.
       # @yield yields the given block.

data/lib/appsignal/integrations/http.rb

@@ -8,13 +8,8 @@ module Appsignal
         parsed_request_uri = uri.is_a?(URI) ? uri : URI.parse(uri.to_s)
         request_uri = "#{parsed_request_uri.scheme}://#{parsed_request_uri.host}"
 
-        begin
-          Appsignal.instrument("request.http_rb", "#{verb.upcase} #{request_uri}") do
-            super
-          end
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          Appsignal.set_error(error)
-          raise error
+        Appsignal.instrument("request.http_rb", "#{verb.upcase} #{request_uri}") do
+          super
         end
       end
     end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.12.6"
+  VERSION = "3.13.0"
 end

data/lib/appsignal.rb

@@ -6,7 +6,7 @@ require "stringio"
 
 require "appsignal/logger"
 require "appsignal/utils/stdout_and_logger_message"
-require "appsignal/helpers/heartbeats"
+require "appsignal/helpers/heartbeat"
 require "appsignal/helpers/instrumentation"
 require "appsignal/helpers/metrics"
 
@@ -18,7 +18,7 @@ require "appsignal/helpers/metrics"
 # {Appsignal::Helpers::Metrics}) for ease of use.
 module Appsignal
   class << self
-    include Helpers::Heartbeats
+    include Helpers::Heartbeat
     include Helpers::Instrumentation
     include Helpers::Metrics
 
@@ -461,6 +461,16 @@ module Appsignal
             "Please update the constant name to Appsignal::Probes " \
             "in the following file to remove this message.\n#{callers.first}"
         Appsignal::Probes
+      when :Heartbeat
+        unless @heartbeat_constant_deprecation_warning_emitted
+          callers = caller
+          Appsignal::Utils::StdoutAndLoggerMessage.warning \
+            "The constant Appsignal::Heartbeat has been deprecated. " \
+              "Please update the constant name to Appsignal::CheckIn::Cron " \
+              "in the following file and elsewhere to remove this message.\n#{callers.first}"
+          @heartbeat_constant_deprecation_warning_emitted = true
+        end
+        Appsignal::CheckIn::Cron
       else
         super
       end
@@ -489,4 +499,4 @@ require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
 require "appsignal/transmitter"
-require "appsignal/heartbeat"
+require "appsignal/check_in"

data/spec/lib/appsignal/check_in_spec.rb

@@ -0,0 +1,342 @@
+describe Appsignal::Heartbeat do
+  let(:err_stream) { std_stream }
+
+  after do
+    Appsignal.instance_variable_set(:@heartbeat_constant_deprecation_warning_emitted, false)
+  end
+
+  it "returns the Cron constant calling the Heartbeat constant" do
+    silence { expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron) }
+  end
+
+  it "prints a deprecation warning to STDERR" do
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+  end
+
+  it "does not print a deprecation warning to STDERR more than once" do
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+
+    err_stream.truncate(0)
+
+    capture_std_streams(std_stream, err_stream) do
+      expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+    end
+
+    expect(err_stream.read)
+      .not_to include("appsignal WARNING: The constant Appsignal::Heartbeat has been deprecated.")
+  end
+
+  it "logs a warning" do
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+  end
+
+  it "does not log a warning more than once" do
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+
+    logs =
+      capture_logs do
+        silence do
+          expect(Appsignal::Heartbeat).to be(Appsignal::CheckIn::Cron)
+        end
+      end
+
+    expect(logs).not_to contains_log(
+      :warn,
+      "The constant Appsignal::Heartbeat has been deprecated."
+    )
+  end
+end
+
+describe "Appsignal.heartbeat" do
+  let(:err_stream) { std_stream }
+
+  before do
+    Appsignal.instance_variable_set(:@heartbeat_helper_deprecation_warning_emitted, false)
+  end
+
+  it "should forward the call to Appsignal::CheckIn.cron" do
+    expect(Appsignal::CheckIn).to receive(:cron).with("heartbeat-name")
+    expect do
+      Appsignal.heartbeat("heartbeat-name")
+    end.not_to raise_error
+
+    block = proc { 42 }
+    expect(Appsignal::CheckIn).to receive(:cron).with("heartbeat-name") do |&given_block|
+      expect(given_block).to be(block)
+    end.and_return("output")
+    expect(Appsignal.heartbeat("heartbeat-name", &block)).to eq("output")
+  end
+
+  it "prints a deprecation warning to STDERR" do
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+  end
+
+  it "does not print a deprecation warning to STDERR more than once" do
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+
+    err_stream.truncate(0)
+
+    capture_std_streams(std_stream, err_stream) do
+      Appsignal.heartbeat("heartbeat-name")
+    end
+
+    expect(err_stream.read)
+      .not_to include("appsignal WARNING: The helper Appsignal.heartbeat has been deprecated.")
+  end
+
+  it "logs a warning" do
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+  end
+
+  it "does not log a warning more than once" do
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+
+    logs =
+      capture_logs do
+        silence do
+          Appsignal.heartbeat("heartbeat-name")
+        end
+      end
+
+    expect(logs).not_to contains_log(
+      :warn,
+      "The helper Appsignal.heartbeat has been deprecated."
+    )
+  end
+end
+
+describe Appsignal::CheckIn::Cron do
+  let(:config) { project_fixture_config }
+  let(:cron_checkin) { described_class.new(:name => "cron-checkin-name") }
+  let(:transmitter) { Appsignal::Transmitter.new("http://cron_checkins/", config) }
+
+  before(:each) do
+    allow(Appsignal).to receive(:active?).and_return(true)
+    config.logger = Logger.new(StringIO.new)
+    allow(Appsignal::CheckIn::Cron).to receive(:transmitter).and_return(transmitter)
+  end
+
+  describe "when Appsignal is not active" do
+    it "should not transmit any events" do
+      allow(Appsignal).to receive(:active?).and_return(false)
+      expect(transmitter).not_to receive(:transmit)
+
+      cron_checkin.start
+      cron_checkin.finish
+    end
+  end
+
+  describe "#start" do
+    it "should send a cron check-in start" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "start",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
+
+      expect(Appsignal.internal_logger).to receive(:debug).with(
+        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) start event"
+      )
+      expect(Appsignal.internal_logger).not_to receive(:error)
+
+      cron_checkin.start
+    end
+
+    it "should log an error if it fails" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "start",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
+
+      expect(Appsignal.internal_logger).not_to receive(:debug)
+      expect(Appsignal.internal_logger).to receive(:error).with(
+        "Failed to transmit cron check-in start event: status code was 499"
+      )
+
+      cron_checkin.start
+    end
+  end
+
+  describe "#finish" do
+    it "should send a cron check-in finish" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "finish",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
+
+      expect(Appsignal.internal_logger).to receive(:debug).with(
+        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) finish event"
+      )
+      expect(Appsignal.internal_logger).not_to receive(:error)
+
+      cron_checkin.finish
+    end
+
+    it "should log an error if it fails" do
+      expect(transmitter).to receive(:transmit).with(hash_including(
+        :identifier => "cron-checkin-name",
+        :kind => "finish",
+        :check_in_type => "cron"
+      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
+
+      expect(Appsignal.internal_logger).not_to receive(:debug)
+      expect(Appsignal.internal_logger).to receive(:error).with(
+        "Failed to transmit cron check-in finish event: status code was 499"
+      )
+
+      cron_checkin.finish
+    end
+  end
+
+  describe ".cron" do
+    describe "when a block is given" do
+      it "should send a cron check-in start and finish and return the block output" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        output = Appsignal::CheckIn.cron("cron-checkin-with-block") { "output" }
+        expect(output).to eq("output")
+      end
+
+      it "should not send a cron check-in finish event when an error is raised" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "start",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        expect(transmitter).not_to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-with-block",
+          :check_in_type => "cron"
+        ))
+
+        expect do
+          Appsignal::CheckIn.cron("cron-checkin-with-block") { raise "error" }
+        end.to raise_error(RuntimeError, "error")
+      end
+    end
+
+    describe "when no block is given" do
+      it "should only send a cron check-in finish event" do
+        expect(transmitter).to receive(:transmit).with(hash_including(
+          :kind => "finish",
+          :identifier => "cron-checkin-without-block",
+          :check_in_type => "cron"
+        )).and_return(nil)
+
+        Appsignal::CheckIn.cron("cron-checkin-without-block")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    describe "when initialised with deprecated heartbeat keyword names" do
+      let(:err_stream) { std_stream }
+
+      after do
+        described_class.instance_variable_set(:@initializer_deprecation_warning_emitted, false)
+      end
+
+      it "can be initialised" do
+        cron_checkin = described_class.new(:name => "cron-checkin-name")
+        expect(cron_checkin.identifier).to eq("cron-checkin-name")
+      end
+
+      it "logs a deprecation warning" do
+        capture_std_streams(std_stream, err_stream) do
+          expect(described_class.new(:name => "cron-checkin-name"))
+            .to be_a(Appsignal::CheckIn::Cron)
+        end
+
+        expect(err_stream.read)
+          .to include(
+            "appsignal WARNING: Passing a `name` keyword argument to " \
+              "`Appsignal::CheckIn::Cron.new` is deprecated."
+          )
+      end
+    end
+
+    it "can be initialised with cron check-in keyword names" do
+      cron_checkin = described_class.new(:identifier => "cron-checkin-name")
+      expect(cron_checkin.identifier).to eq("cron-checkin-name")
+    end
+
+    it "raises an error when no identifier is given" do
+      expect do
+        described_class.new
+      end.to raise_error(ArgumentError, "missing keyword: :identifier")
+    end
+  end
+end

data/spec/lib/appsignal/integrations/http_spec.rb

@@ -67,27 +67,6 @@ if DependencyHelper.http_present?
       end
     end
 
-    context "with an HTTP exception" do
-      let(:error) { ExampleException.new("oh no!") }
-
-      it "reports the exception and re-raises it" do
-        stub_request(:get, "https://www.google.com").and_raise(error)
-
-        expect do
-          HTTP.get("https://www.google.com")
-        end.to raise_error(ExampleException)
-
-        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        expect(transaction).to include_event(
-          "body" => "",
-          "body_format" => Appsignal::EventFormatter::DEFAULT,
-          "name" => "request.http_rb",
-          "title" => "GET https://www.google.com"
-        )
-        expect(transaction).to have_error(error.class.name, error.message)
-      end
-    end
-
     context "with various URI objects" do
       it "parses an object responding to #to_s" do
         request_uri = Struct.new(:uri) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.12.6
+  version: 3.13.0
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 2024-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -186,6 +186,8 @@ files:
 - lib/appsignal.rb
 - lib/appsignal/auth_check.rb
 - lib/appsignal/capistrano.rb
+- lib/appsignal/check_in.rb
+- lib/appsignal/check_in/cron.rb
 - lib/appsignal/cli.rb
 - lib/appsignal/cli/demo.rb
 - lib/appsignal/cli/diagnose.rb
@@ -209,8 +211,7 @@ files:
 - lib/appsignal/extension.rb
 - lib/appsignal/extension/jruby.rb
 - lib/appsignal/garbage_collection.rb
-- lib/appsignal/heartbeat.rb
-- lib/appsignal/helpers/heartbeats.rb
+- lib/appsignal/helpers/heartbeat.rb
 - lib/appsignal/helpers/instrumentation.rb
 - lib/appsignal/helpers/metrics.rb
 - lib/appsignal/hooks.rb
@@ -312,6 +313,7 @@ files:
 - spec/lib/appsignal/auth_check_spec.rb
 - spec/lib/appsignal/capistrano2_spec.rb
 - spec/lib/appsignal/capistrano3_spec.rb
+- spec/lib/appsignal/check_in_spec.rb
 - spec/lib/appsignal/cli/demo_spec.rb
 - spec/lib/appsignal/cli/diagnose/paths_spec.rb
 - spec/lib/appsignal/cli/diagnose/utils_spec.rb
@@ -336,7 +338,6 @@ files:
 - spec/lib/appsignal/extension_install_failure_spec.rb
 - spec/lib/appsignal/extension_spec.rb
 - spec/lib/appsignal/garbage_collection_spec.rb
-- spec/lib/appsignal/heartbeat_spec.rb
 - spec/lib/appsignal/hooks/action_cable_spec.rb
 - spec/lib/appsignal/hooks/action_mailer_spec.rb
 - spec/lib/appsignal/hooks/active_support_notifications/finish_with_state_shared_examples.rb
@@ -488,7 +489,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com

data/lib/appsignal/heartbeat.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  class Heartbeat
-    class << self
-      # @api private
-      def transmitter
-        @transmitter ||= Appsignal::Transmitter.new(
-          "#{Appsignal.config[:logging_endpoint]}/heartbeats/json"
-        )
-      end
-    end
-
-    attr_reader :name, :id
-
-    def initialize(name:)
-      @name = name
-      @id = SecureRandom.hex(8)
-    end
-
-    def start
-      transmit_event("start")
-    end
-
-    def finish
-      transmit_event("finish")
-    end
-
-    private
-
-    def event(kind)
-      {
-        :name => name,
-        :id => @id,
-        :kind => kind,
-        :timestamp => Time.now.utc.to_i
-      }
-    end
-
-    def transmit_event(kind)
-      unless Appsignal.active?
-        Appsignal.internal_logger.debug("AppSignal not active, not transmitting heartbeat event")
-        return
-      end
-
-      response = self.class.transmitter.transmit(event(kind))
-
-      if response.code.to_i >= 200 && response.code.to_i < 300
-        Appsignal.internal_logger.debug("Transmitted heartbeat `#{name}` (#{id}) #{kind} event")
-      else
-        Appsignal.internal_logger.error(
-          "Failed to transmit heartbeat event: status code was #{response.code}"
-        )
-      end
-    rescue => e
-      Appsignal.internal_logger.error("Failed to transmit heartbeat event: #{e}")
-    end
-  end
-end

data/lib/appsignal/helpers/heartbeats.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  module Helpers
-    module Heartbeats
-      # Track heartbeats
-      #
-      # Track the execution of certain processes by sending a hearbeat.
-      #
-      # To track the duration of a piece of code, pass a block to {.heartbeat}
-      # to report both when the process starts, and when it finishes.
-      #
-      # If an exception is raised within the block, the finish event will not
-      # be reported, triggering a notification about the missing heartbeat. The
-      # exception will bubble outside of the heartbeat block.
-      #
-      # @example Send a heartbeat
-      #   Appsignal.heartbeat("send_invoices")
-      #
-      # @example Send a heartbeat with duration
-      #   Appsignal.heartbeat("send_invoices") do
-      #     # your code
-      #   end
-      #
-      # @param name [String] name of the heartbeat to report.
-      # @yield the block to monitor.
-      # @return [void]
-      # @since 3.7.0
-      # @see https://docs.appsignal.com/heartbeats
-      def heartbeat(name)
-        heartbeat = Appsignal::Heartbeat.new(:name => name)
-        output = nil
-
-        if block_given?
-          heartbeat.start
-          output = yield
-        end
-
-        heartbeat.finish
-        output
-      end
-    end
-  end
-end

data/spec/lib/appsignal/heartbeat_spec.rb

@@ -1,127 +0,0 @@
-describe Appsignal::Heartbeat do
-  let(:config) { project_fixture_config }
-  let(:heartbeat) { described_class.new(:name => "heartbeat-name") }
-  let(:transmitter) { Appsignal::Transmitter.new("http://heartbeats/", config) }
-
-  before(:each) do
-    allow(Appsignal).to receive(:active?).and_return(true)
-    config.logger = Logger.new(StringIO.new)
-    allow(Appsignal::Heartbeat).to receive(:transmitter).and_return(transmitter)
-  end
-
-  describe "when Appsignal is not active" do
-    it "should not transmit any events" do
-      allow(Appsignal).to receive(:active?).and_return(false)
-      expect(transmitter).not_to receive(:transmit)
-
-      heartbeat.start
-      heartbeat.finish
-    end
-  end
-
-  describe "#start" do
-    it "should send a heartbeat start" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :name => "heartbeat-name",
-        :kind => "start"
-      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Transmitted heartbeat `heartbeat-name` (#{heartbeat.id}) start event"
-      )
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      heartbeat.start
-    end
-
-    it "should log an error if it fails" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :name => "heartbeat-name",
-        :kind => "start"
-      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      expect(Appsignal.internal_logger).not_to receive(:debug)
-      expect(Appsignal.internal_logger).to receive(:error).with(
-        "Failed to transmit heartbeat event: status code was 499"
-      )
-
-      heartbeat.start
-    end
-  end
-
-  describe "#finish" do
-    it "should send a heartbeat finish" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :name => "heartbeat-name",
-        :kind => "finish"
-      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Transmitted heartbeat `heartbeat-name` (#{heartbeat.id}) finish event"
-      )
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      heartbeat.finish
-    end
-
-    it "should log an error if it fails" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :name => "heartbeat-name",
-        :kind => "finish"
-      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      expect(Appsignal.internal_logger).not_to receive(:debug)
-      expect(Appsignal.internal_logger).to receive(:error).with(
-        "Failed to transmit heartbeat event: status code was 499"
-      )
-
-      heartbeat.finish
-    end
-  end
-
-  describe ".heartbeat" do
-    describe "when a block is given" do
-      it "should send a heartbeat start and finish and return the block output" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "start",
-          :name => "heartbeat-with-block"
-        )).and_return(nil)
-
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :name => "heartbeat-with-block"
-        )).and_return(nil)
-
-        output = Appsignal.heartbeat("heartbeat-with-block") { "output" }
-        expect(output).to eq("output")
-      end
-
-      it "should not send a heartbeat finish event when an error is raised" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "start",
-          :name => "heartbeat-with-block"
-        )).and_return(nil)
-
-        expect(transmitter).not_to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :name => "heartbeat-with-block"
-        ))
-
-        expect do
-          Appsignal.heartbeat("heartbeat-with-block") { raise "error" }
-        end.to raise_error(RuntimeError, "error")
-      end
-    end
-
-    describe "when no block is given" do
-      it "should only send a heartbeat finish event" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :name => "heartbeat-without-block"
-        )).and_return(nil)
-
-        Appsignal.heartbeat("heartbeat-without-block")
-      end
-    end
-  end
-end