appsignal 3.7.5 → 3.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01c402441faf18659ecff6becf0b7ae9db255825cc873edd5bf2ccc3aaa62c6b
-  data.tar.gz: 3b9e4c29a62c073f8c9395c26f26dcfc4496af5ca9352193f04983d11bca9476
+  metadata.gz: f68ce83624657d12b65c203950c7a92681d621bc9f5644fcc61d4123417e8e93
+  data.tar.gz: ecda706a29b6aea7d52d3620cebb984495c85937acf561a596826fd57c457095
 SHA512:
-  metadata.gz: 3c1994c27480cbc29310b88c81ad09534885cf3acd43b7d2439921cf54c2f252023b44e0bf40c0f4b6fa4145fc86f2ba9ff36feca8357874576e928c75bec3e4
-  data.tar.gz: 2d77c4799ba521b3832ebba0d632a70774d767a92e694cfa23a6e82c4c25c05556f5ebad03e571e09d1ce34be234ac7ede1ae3df601247b23cb4df7ccadfe5a9
+  metadata.gz: 9ec9d7754da4808d85efd335d8e9c00bca8f0e2c16f7a4a9246b9bd9d679519c7550202c1d2f809c786e117cde31c76c8c3405664b9878b9b8c61724a05dca14
+  data.tar.gz: 955a45291f05e0df7456ae7bef0c7d9be55824b764429a6fffd72985ee252dcf83893e824a610d086c82c0050ae14bb6ddebc6baaf600946c1d50ce55a3ae4d7

data/.github/workflows/create_release_from_tag.yml

@@ -0,0 +1,62 @@
+name: "Create release from tag"
+
+on:
+  push:
+    tags:
+      - "v**"
+
+permissions:
+  contents: write
+  actions: write
+
+jobs:
+  release:
+    name: "Create release"
+    runs-on: ubuntu-latest
+    env:
+      PACKAGE_NAME: "Ruby gem"
+      CHANGELOG_CATEGORY: "Ruby"
+      CHANGELOG_LINK: "https://github.com/appsignal/appsignal-ruby/blob/main/CHANGELOG.md"
+    steps:
+      - name: Checkout repository at tag
+        uses: actions/checkout@v4
+        with:
+          ref: "${{ github.ref }}"
+
+      - name: Get tag name
+        run: |
+          echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+
+      - name: Get changelog contents from tag
+        run: |
+          # Use sed to remove everything after "-----BEGIN PGP SIGNATURE-----" if it's present
+          # and also always remove the last line of the git show output
+          git show --format=oneline --no-color --no-patch "${{ env.TAG_NAME }}" \
+          | sed '1,2d' \
+          | sed '$d' \
+          | sed '/-----BEGIN PGP SIGNATURE-----/,$d' \
+          > CHANGELOG_TEXT.txt
+
+          echo "" >> CHANGELOG_TEXT.txt
+          echo "" >> CHANGELOG_TEXT.txt
+
+          TAG_NAME_FOR_LINK=$(echo "${{ env.TAG_NAME }}" | sed 's/^v//' | tr -d '.')
+          echo "View the [$PACKAGE_NAME ${{ env.TAG_NAME }} changelog]($CHANGELOG_LINK#$TAG_NAME_FOR_LINK) for more information." >> CHANGELOG_TEXT.txt
+
+      - name: Submit changelog entry
+        run: |
+          # Prepare JSON payload using jq to ensure proper escaping
+          payload=$(jq -n \
+            --arg title "$PACKAGE_NAME ${{ env.TAG_NAME }}" \
+            --arg category "$CHANGELOG_CATEGORY" \
+            --arg version "$(echo "${{ env.TAG_NAME }}" | sed 's/^v//')" \
+            --arg changelog "$(cat CHANGELOG_TEXT.txt)" \
+            --arg assignee "${{ github.actor }}" \
+            '{ref: "main", inputs: {title: $title, category: $category, version: $version, changelog: $changelog, assignee: $assignee}}')
+
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.INTEGRATIONS_CHANGELOG_TOKEN }}" \
+            -H "Accept: application/vnd.github+json" \
+            --fail-with-body \
+            https://api.github.com/repos/appsignal/appsignal.com/actions/workflows/102125282/dispatches \
+            -d "$payload"

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.8.1
+
+_Published on 2024-06-17._
+
+### Added
+
+- [5459a021](https://github.com/appsignal/appsignal-ruby/commit/5459a021d7d4bbbd09a0dcbdf5f3af7bf861b6f5) patch - Report the response status for Rails requests as the `response_status` tag on samples, e.g. 200, 301, 500. This tag is visible on the sample detail page.
+  
+  The response status is also reported as the `response_status` metric.
+
+## 3.8.0
+
+_Published on 2024-06-17._
+
+### Changed
+
+- [ca53b043](https://github.com/appsignal/appsignal-ruby/commit/ca53b04360ae123498640d043ee7ba74efc4b295) minor - Report the time spent in Rails middleware as part of the request duration. The AppSignal Rack middleware is now higher in the middleware stack and reports more time of the request to give insights in how long other middleware took. This is reported under the new `process_request.rack` event in the event timeline.
+
+### Fixed
+
+- [37fbae5a](https://github.com/appsignal/appsignal-ruby/commit/37fbae5a0f1a4e964baceb21837e5d5f0cf903c0) patch - Fix ArgumentError being raised on Ruby logger and Rails.logger error calls. This fixes the error from being raised from within the AppSignal Ruby gem.
+  Please do not use this for error reporting. We recommend using our error reporting feature instead to be notified of new errors. Read more on [exception handling in Ruby with our Ruby gem](https://docs.appsignal.com/ruby/instrumentation/exception-handling.html).
+  
+  ```ruby
+  # No longer raises an error
+  Rails.logger.error StandardError.new("StandardError log message")
+  ```
+
+## 3.7.6
+
+_Published on 2024-06-11._
+
+### Changed
+
+- [704a7d29](https://github.com/appsignal/appsignal-ruby/commit/704a7d29ae428f93549000a2c606bff948040c96) patch - When the minutely probes thread takes more than 60 seconds to run all the registered probes, log an error. This helps find issues with the metrics reported by the probes not being accurately reported for every minute.
+- [5f4cc8be](https://github.com/appsignal/appsignal-ruby/commit/5f4cc8beb0ad88a0a58265d990626a7ee39fddd3) patch - Internal agent changes for the Ruby gem.
+
 ## 3.7.5
 
 _Published on 2024-05-14._

data/ext/agent.rb

@@ -6,7 +6,7 @@
 # Modifications to this file will be overwritten with the next agent release.
 
 APPSIGNAL_AGENT_CONFIG = {
-  "version" => "0.35.10",
+  "version" => "0.35.12",
   "mirrors" => [
     "https://appsignal-agent-releases.global.ssl.fastly.net",
     "https://d135dj0rjqvssy.cloudfront.net"
@@ -14,131 +14,131 @@ APPSIGNAL_AGENT_CONFIG = {
   "triples" => {
     "x86_64-darwin" => {
       "static" => {
-        "checksum" => "8bdf6b162e03c5f63bc06f2d49ae789bb14e111636524ed78262bd543587a971",
+        "checksum" => "61210c40be70e0616a356d06040961b096e2d47332021a52f3779912a9fe0e4c",
         "filename" => "appsignal-x86_64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "92535e45232d5fe2eb7b9ff2f731115de566144390cd281449acd5c3a570ebb5",
+        "checksum" => "dd165289445c80e4dcc148ea09c613b23b001c90ad885aef1de08db65ab5bf1c",
         "filename" => "appsignal-x86_64-darwin-all-dynamic.tar.gz"
       }
     },
     "universal-darwin" => {
       "static" => {
-        "checksum" => "8bdf6b162e03c5f63bc06f2d49ae789bb14e111636524ed78262bd543587a971",
+        "checksum" => "61210c40be70e0616a356d06040961b096e2d47332021a52f3779912a9fe0e4c",
         "filename" => "appsignal-x86_64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "92535e45232d5fe2eb7b9ff2f731115de566144390cd281449acd5c3a570ebb5",
+        "checksum" => "dd165289445c80e4dcc148ea09c613b23b001c90ad885aef1de08db65ab5bf1c",
         "filename" => "appsignal-x86_64-darwin-all-dynamic.tar.gz"
       }
     },
     "aarch64-darwin" => {
       "static" => {
-        "checksum" => "c6453bb54a68cdb0b42864747b328e60a14b5b99921f11757de03db42041bed2",
+        "checksum" => "9b97c42561450f9af9ae63816d32b8db69be6f2745226f63d6eada4369c68a20",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "920fa90c131752a40287b55356cd2360e17417753087b74dbf63c339f04dacc9",
+        "checksum" => "0c81959ab5de3c98c70b7e308826d7deee8e208ee47b7637d505b0a1d70af8c4",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "arm64-darwin" => {
       "static" => {
-        "checksum" => "c6453bb54a68cdb0b42864747b328e60a14b5b99921f11757de03db42041bed2",
+        "checksum" => "9b97c42561450f9af9ae63816d32b8db69be6f2745226f63d6eada4369c68a20",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "920fa90c131752a40287b55356cd2360e17417753087b74dbf63c339f04dacc9",
+        "checksum" => "0c81959ab5de3c98c70b7e308826d7deee8e208ee47b7637d505b0a1d70af8c4",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "arm-darwin" => {
       "static" => {
-        "checksum" => "c6453bb54a68cdb0b42864747b328e60a14b5b99921f11757de03db42041bed2",
+        "checksum" => "9b97c42561450f9af9ae63816d32b8db69be6f2745226f63d6eada4369c68a20",
         "filename" => "appsignal-aarch64-darwin-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "920fa90c131752a40287b55356cd2360e17417753087b74dbf63c339f04dacc9",
+        "checksum" => "0c81959ab5de3c98c70b7e308826d7deee8e208ee47b7637d505b0a1d70af8c4",
         "filename" => "appsignal-aarch64-darwin-all-dynamic.tar.gz"
       }
     },
     "aarch64-linux" => {
       "static" => {
-        "checksum" => "4e90ec4bce1e632316a26fdaf03ccd8773bf7a9615eb7a1739c8c53f3fa5221a",
+        "checksum" => "358db07cfa85d6bd048bd2bb05fc9607d4fe0d4396fd023d658e945e4a675fba",
         "filename" => "appsignal-aarch64-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "d4e5811ab29f801c59caafe445a06c686245666459a45a28240c2db7395abf27",
+        "checksum" => "9e76651d52f78882ab126d94a8af61794d1ce0cdffa6dd01a3e032599a1b2796",
         "filename" => "appsignal-aarch64-linux-all-dynamic.tar.gz"
       }
     },
     "i686-linux" => {
       "static" => {
-        "checksum" => "f5bcb9f732cb5af53a5de2f2c916156bdd6677c0e563ddafd23f09576440dfdc",
+        "checksum" => "315bf1fc5d9c97b6f26e61f5e39919e0ba425b1d96ea6243cdb2f650487c407e",
         "filename" => "appsignal-i686-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "52bf105113a3dbe1e9527c0c733edd3ee05788e340bd41577ed38878df6748f0",
+        "checksum" => "8cf0b5e6ef70a7758b98457012bfebb7964acb2d47648f3817c9f32a70bc0ab1",
         "filename" => "appsignal-i686-linux-all-dynamic.tar.gz"
       }
     },
     "x86-linux" => {
       "static" => {
-        "checksum" => "f5bcb9f732cb5af53a5de2f2c916156bdd6677c0e563ddafd23f09576440dfdc",
+        "checksum" => "315bf1fc5d9c97b6f26e61f5e39919e0ba425b1d96ea6243cdb2f650487c407e",
         "filename" => "appsignal-i686-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "52bf105113a3dbe1e9527c0c733edd3ee05788e340bd41577ed38878df6748f0",
+        "checksum" => "8cf0b5e6ef70a7758b98457012bfebb7964acb2d47648f3817c9f32a70bc0ab1",
         "filename" => "appsignal-i686-linux-all-dynamic.tar.gz"
       }
     },
     "x86_64-linux" => {
       "static" => {
-        "checksum" => "6faa14f508f7c27b65d912eedb31f7808e1e2fb1dcaa077db2426c321e1f5c65",
+        "checksum" => "3fe42df2a52706c23f967b8421ac816fa37a38998bd24b1d6aafd59a324b23ff",
         "filename" => "appsignal-x86_64-linux-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "0981839a288dc2ab6d024bae79789a20f5cadce55c4cbcade925066b83028b65",
+        "checksum" => "8781f0a4c4810229f19000ebb882b7d8e5e0440ffcf8e5ffea7d68d082be8e69",
         "filename" => "appsignal-x86_64-linux-all-dynamic.tar.gz"
       }
     },
     "x86_64-linux-musl" => {
       "static" => {
-        "checksum" => "8f54b734e56eae7867b5474c7ad4d79e049fd4063202e1b80989795708354e49",
+        "checksum" => "1fe0ed0c0ca51eccd4c2ec3bb94bb1834bae19bc2c185b67c3f940f704abe9fc",
         "filename" => "appsignal-x86_64-linux-musl-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "01df4f408e2c0f83204bedfe33e132bfdc6c4a9dcff6581bacf30df45140a49e",
+        "checksum" => "f241f905555e17178a72b217dc373ead33daa97757e100b895f2d1318e4dce0d",
         "filename" => "appsignal-x86_64-linux-musl-all-dynamic.tar.gz"
       }
     },
     "aarch64-linux-musl" => {
       "static" => {
-        "checksum" => "b3d247d632e3465b2233dd8bb2e977f248f14286ca870e9bd7b855b550ba1c00",
+        "checksum" => "5027782008872f8091608cc5531a6dd90f0652e9ebb0404f7e86eb73f0807ba0",
         "filename" => "appsignal-aarch64-linux-musl-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "52d4a422bcf3a9bbbb6119abae21f6b1d1191309103bcfb90a1f786b1af64a71",
+        "checksum" => "ae3147790f25cef200142f61eb6ce1f8b3ac5fa2647ad7a4234f1bbb976bde98",
         "filename" => "appsignal-aarch64-linux-musl-all-dynamic.tar.gz"
       }
     },
     "x86_64-freebsd" => {
       "static" => {
-        "checksum" => "1cce550eac963e2edf405e551a613ffd15ae69e4b817b6155b8a5783a9fa9b7f",
+        "checksum" => "1337268caaddd66bb170298968d50d76cc66f17e808c46a677ba00d1b78eb317",
         "filename" => "appsignal-x86_64-freebsd-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "ea67b696f806127ac7e59d3dd02a5ca47de1526455b957bad4fd69d9b08913fe",
+        "checksum" => "2b93af244d1d214b59c2657677bf96445f67cade2fa1bfd6cda78c8bec75cbca",
         "filename" => "appsignal-x86_64-freebsd-all-dynamic.tar.gz"
       }
     },
     "amd64-freebsd" => {
       "static" => {
-        "checksum" => "1cce550eac963e2edf405e551a613ffd15ae69e4b817b6155b8a5783a9fa9b7f",
+        "checksum" => "1337268caaddd66bb170298968d50d76cc66f17e808c46a677ba00d1b78eb317",
         "filename" => "appsignal-x86_64-freebsd-all-static.tar.gz"
       },
       "dynamic" => {
-        "checksum" => "ea67b696f806127ac7e59d3dd02a5ca47de1526455b957bad4fd69d9b08913fe",
+        "checksum" => "2b93af244d1d214b59c2657677bf96445f67cade2fa1bfd6cda78c8bec75cbca",
         "filename" => "appsignal-x86_64-freebsd-all-dynamic.tar.gz"
       }
     }

data/gemfiles/grape.gemfile

@@ -1,6 +1,5 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-gem 'grape'
-gem 'activesupport', '~> 4.2'
+gem "grape"
 
-gemspec :path => '../'
+gemspec :path => "../"

data/lib/appsignal/heartbeat.rb

@@ -3,6 +3,7 @@
 module Appsignal
   class Heartbeat
     class << self
+      # @api private
       def transmitter
         @transmitter ||= Appsignal::Transmitter.new(
           "#{Appsignal.config[:logging_endpoint]}/heartbeats/json"
@@ -55,17 +56,4 @@ module Appsignal
       Appsignal.internal_logger.error("Failed to transmit heartbeat event: #{e}")
     end
   end
-
-  def self.heartbeat(name)
-    heartbeat = Appsignal::Heartbeat.new(:name => name)
-    output = nil
-
-    if block_given?
-      heartbeat.start
-      output = yield
-    end
-
-    heartbeat.finish
-    output
-  end
 end

data/lib/appsignal/helpers/heartbeats.rb

@@ -0,0 +1,44 @@
+# 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/lib/appsignal/integrations/railtie.rb

@@ -29,6 +29,11 @@ module Appsignal
         # Start logger
         Appsignal.start_logger
 
+        app.middleware.insert(
+          0,
+          ::Rack::Events,
+          [Appsignal::Rack::EventHandler.new]
+        )
         app.middleware.insert_after(
           ActionDispatch::DebugExceptions,
           Appsignal::Rack::RailsInstrumentation

data/lib/appsignal/logger.rb

@@ -53,6 +53,13 @@ module Appsignal
 
       message = formatter.call(severity, Time.now, group, message) if formatter
 
+      unless message.is_a?(String)
+        Appsignal.internal_logger.warn(
+          "Logger message was ignored, because it was not a String: #{message.inspect}"
+        )
+        return
+      end
+
       Appsignal::Extension.log(
         group,
         SEVERITY_MAP.fetch(severity, 0),
@@ -112,6 +119,8 @@ module Appsignal
       message = yield if message.nil? && block_given?
       return if message.nil?
 
+      message = "#{message.class}: #{message.message}" if message.is_a?(Exception)
+
       add_with_attributes(ERROR, message, @group, attributes)
     end
 

data/lib/appsignal/probes.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 module Appsignal
-  module Probes
+  module Probes # rubocop:disable Metrics/ModuleLength
+    ITERATION_IN_SECONDS = 60
+
     class ProbeCollection
       def initialize
         @probes = {}
@@ -180,6 +182,7 @@ module Appsignal
           sleep initial_wait_time
           initialize_probes
           loop do
+            start_time = Time.now
             logger = Appsignal.internal_logger
             mutex.synchronize do
               logger.debug("Gathering minutely metrics with #{probe_instances.count} probes")
@@ -191,6 +194,15 @@ module Appsignal
                 logger.debug ex.backtrace.join("\n")
               end
             end
+            end_time = Time.now
+            duration = end_time - start_time
+            if duration >= ITERATION_IN_SECONDS
+              logger.error(
+                "The minutely probes took more than 60 seconds. " \
+                  "The probes should not take this long as metrics will not " \
+                  "be accurately reported."
+              )
+            end
             sleep wait_time
           end
         end
@@ -214,16 +226,16 @@ module Appsignal
 
       # @api private
       def wait_time
-        60 - Time.now.sec
+        ITERATION_IN_SECONDS - Time.now.sec
       end
 
       private
 
       def initial_wait_time
-        remaining_seconds = 60 - Time.now.sec
+        remaining_seconds = ITERATION_IN_SECONDS - Time.now.sec
         return remaining_seconds if remaining_seconds > 30
 
-        remaining_seconds + 60
+        remaining_seconds + ITERATION_IN_SECONDS
       end
 
       def initialize_probes

data/lib/appsignal/rack/event_handler.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    APPSIGNAL_TRANSACTION = "appsignal.transaction"
+    RACK_AFTER_REPLY = "rack.after_reply"
+
+    class EventHandler
+      include ::Rack::Events::Abstract
+
+      def self.safe_execution(name)
+        yield
+      rescue => e
+        Appsignal.internal_logger.error(
+          "Error occurred in #{name}: #{e.class}: #{e}: #{e.backtrace}"
+        )
+      end
+
+      def on_start(request, _response)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_start") do
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid,
+            Appsignal::Transaction::HTTP_REQUEST,
+            request
+          )
+          request.env[APPSIGNAL_TRANSACTION] = transaction
+
+          request.env[RACK_AFTER_REPLY] ||= []
+          request.env[RACK_AFTER_REPLY] << proc do
+            Appsignal::Rack::EventHandler
+              .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
+              transaction.finish_event("process_request.rack", "", "")
+              transaction.set_http_or_background_queue_start
+
+              # Make sure the current transaction is always closed when the request
+              # is finished. This is a fallback for in case the `on_finish`
+              # callback is not called. This is supported by servers like Puma and
+              # Unicorn.
+              #
+              # The EventHandler.on_finish callback should be called first, this is
+              # just a fallback if that doesn't get called.
+              Appsignal::Transaction.complete_current!
+            end
+          end
+          transaction.start_event
+        end
+      end
+
+      def on_error(request, _response, error)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
+          transaction = request.env[APPSIGNAL_TRANSACTION]
+          return unless transaction
+
+          transaction.set_error(error)
+        end
+      end
+
+      def on_finish(request, response)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
+          transaction = request.env[APPSIGNAL_TRANSACTION]
+          return unless transaction
+
+          transaction.finish_event("process_request.rack", "", "")
+          transaction.set_tags(:response_status => response.status)
+          transaction.set_http_or_background_queue_start
+          Appsignal.increment_counter(
+            :response_status,
+            1,
+            :status => response.status,
+            :namespace => format_namespace(transaction.namespace)
+          )
+
+          # Make sure the current transaction is always closed when the request
+          # is finished
+          Appsignal::Transaction.complete_current!
+        end
+      end
+
+      private
+
+      def format_namespace(namespace)
+        if namespace == Appsignal::Transaction::HTTP_REQUEST
+          :web
+        else
+          namespace
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -22,13 +22,14 @@ module Appsignal
 
       def call_with_appsignal_monitoring(env)
         request = ActionDispatch::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          request_id(env),
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          :params_method => :filtered_parameters
+        transaction = env.fetch(
+          Appsignal::Rack::APPSIGNAL_TRANSACTION,
+          Appsignal::Transaction::NilTransaction.new
         )
+
         begin
+          transaction.params = fetch_params(request)
+
           @app.call(env)
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
@@ -38,19 +39,33 @@ module Appsignal
           if controller
             transaction.set_action_if_nil("#{controller.class}##{controller.action_name}")
           end
-          transaction.set_http_or_background_queue_start
+          request_id = fetch_request_id(env)
+          transaction.set_tags(:request_id => request_id) if request_id
           transaction.set_metadata("path", request.path)
-          begin
-            transaction.set_metadata("method", request.request_method)
-          rescue => error
-            Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
-          end
-          Appsignal::Transaction.complete_current!
+          request_method = fetch_request_method(request)
+          transaction.set_metadata("method", request_method) if request_method
         end
       end
 
-      def request_id(env)
-        env["action_dispatch.request_id"] || SecureRandom.uuid
+      def fetch_request_id(env)
+        env["action_dispatch.request_id"]
+      end
+
+      def fetch_params(request)
+        return unless request.respond_to?(:filtered_parameters)
+
+        request.filtered_parameters
+      rescue => error
+        # Getting params from the request has been know to fail.
+        Appsignal.internal_logger.debug "Exception while getting Rails params: #{error}"
+        nil
+      end
+
+      def fetch_request_method(request)
+        request.request_method
+      rescue => error
+        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
+        nil
       end
     end
   end

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -6,6 +6,7 @@ require "stringio"
 
 require "appsignal/logger"
 require "appsignal/utils/stdout_and_logger_message"
+require "appsignal/helpers/heartbeats"
 require "appsignal/helpers/instrumentation"
 require "appsignal/helpers/metrics"
 
@@ -17,6 +18,7 @@ require "appsignal/helpers/metrics"
 # {Appsignal::Helpers::Metrics}) for ease of use.
 module Appsignal
   class << self
+    include Helpers::Heartbeats
     include Helpers::Instrumentation
     include Helpers::Metrics
 
@@ -95,11 +97,11 @@ module Appsignal
     # @since 0.7.0
     def start
       unless extension_loaded?
-        internal_logger.info("Not starting appsignal, extension is not loaded")
+        internal_logger.info("Not starting AppSignal, extension is not loaded")
         return
       end
 
-      internal_logger.debug("Starting appsignal")
+      internal_logger.debug("Loading AppSignal gem")
 
       @config ||= Config.new(
         Dir.pwd,
@@ -325,5 +327,6 @@ require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
 require "appsignal/rack/generic_instrumentation"
+require "appsignal/rack/event_handler"
 require "appsignal/transmitter"
 require "appsignal/heartbeat"

data/spec/lib/appsignal/logger_spec.rb

@@ -1,6 +1,12 @@
 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)
@@ -14,6 +20,19 @@ describe Appsignal::Logger do
       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))
@@ -162,4 +181,25 @@ describe Appsignal::Logger do
       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/probes_spec.rb

@@ -215,6 +215,29 @@ describe Appsignal::Probes do
       end
     end
 
+    context "with a probe that takes 60 seconds" do
+      it "logs an error and continues calling the probes every <wait_time>" do
+        stub_const("Appsignal::Probes::ITERATION_IN_SECONDS", 0.2)
+        calls = 0
+        probe = lambda do
+          calls += 1
+          sleep 0.2
+        end
+        Appsignal::Probes.register :my_probe, probe
+        Appsignal::Probes.register :other_probe, lambda {}
+        Appsignal::Probes.start
+
+        wait_for("enough probe calls") { calls >= 2 }
+
+        expect(log).to contains_log(
+          :error,
+          "The minutely probes took more than 60 seconds. " \
+            "The probes should not take this long as metrics will not " \
+            "be accurately reported."
+        )
+      end
+    end
+
     it "ensures only one minutely probes thread is active at a time" do
       alive_thread_counter = proc { Thread.list.reject { |t| t.status == "dead" }.length }
       probe = MockProbe.new
@@ -240,10 +263,6 @@ describe Appsignal::Probes do
     end
 
     context "with thread already started" do
-      before do
-        allow(Appsignal::Probes).to receive(:initial_wait_time).and_return(0.00001)
-      end
-
       it "auto starts probes added after the thread is started" do
         Appsignal::Probes.start
         wait_for("Probes thread to start") { Appsignal::Probes.started? }
@@ -290,7 +309,7 @@ describe Appsignal::Probes do
 
   describe ".stop" do
     before do
-      allow(Appsignal::Probes).to receive(:initial_wait_time).and_return(0.001)
+      speed_up_tests!
     end
 
     it "stops the minutely thread" do

data/spec/lib/appsignal/rack/event_handler_spec.rb

@@ -0,0 +1,218 @@
+describe Appsignal::Rack::EventHandler do
+  let(:queue_start_time) { fixed_time * 1_000 }
+  let(:env) do
+    {
+      "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}", # in milliseconds
+      "REQUEST_METHOD" => "GET",
+      "PATH_INFO" => "/path"
+    }
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:response) { nil }
+  let(:log_stream) { StringIO.new }
+  let(:log) { log_contents(log_stream) }
+  before do
+    start_agent
+    Appsignal.internal_logger = test_logger(log_stream)
+  end
+  around { |example| keep_transactions { example.run } }
+
+  def on_start
+    described_class.new.on_start(request, response)
+  end
+
+  describe "#on_start" do
+    it "creates a new transaction" do
+      expect { on_start }.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction.to_h).to include(
+        "id" => kind_of(String),
+        "namespace" => Appsignal::Transaction::HTTP_REQUEST
+      )
+
+      expect(Appsignal::Transaction.current).to eq(last_transaction)
+    end
+
+    it "registers transaction on the request environment" do
+      on_start
+
+      expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+        .to eq(last_transaction)
+    end
+
+    it "registers an rack.after_reply callback that completes the transaction" do
+      request.env[Appsignal::Rack::RACK_AFTER_REPLY] = []
+      expect do
+        on_start
+      end.to change { request.env[Appsignal::Rack::RACK_AFTER_REPLY].length }.by(1)
+
+      expect(Appsignal::Transaction.current).to eq(last_transaction)
+
+      callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
+      callback.call
+
+      expect(Appsignal::Transaction.current).to be_kind_of(Appsignal::Transaction::NilTransaction)
+
+      expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+    end
+
+    it "logs errors from rack.after_reply callbacks" do
+      on_start
+
+      expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+        .to receive(:finish_event)
+        .and_raise(ExampleStandardError, "oh no")
+      callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
+      callback.call
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler's after_reply: ExampleStandardError: oh no"
+      )
+    end
+
+    it "logs an error in case of an error" do
+      expect(Appsignal::Transaction)
+        .to receive(:create).and_raise(ExampleStandardError, "oh no")
+
+      on_start
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_start: ExampleStandardError: oh no"
+      )
+    end
+  end
+
+  describe "#on_error" do
+    def on_error(error)
+      described_class.new.on_error(request, response, error)
+    end
+
+    it "reports the error" do
+      on_start
+      on_error(ExampleStandardError.new("the error"))
+
+      expect(last_transaction.to_h).to include(
+        "error" => {
+          "name" => "ExampleStandardError",
+          "message" => "the error",
+          "backtrace" => kind_of(String)
+        }
+      )
+    end
+
+    it "logs an error in case of an internal error" do
+      on_start
+
+      expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+        .to receive(:set_error).and_raise(ExampleStandardError, "oh no")
+
+      on_error(ExampleStandardError.new("the error"))
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_error: ExampleStandardError: oh no"
+      )
+    end
+  end
+
+  describe "#on_finish" do
+    let(:response) { Rack::Events::BufferedResponse.new(200, {}, ["body"]) }
+
+    def on_finish
+      described_class.new.on_finish(request, response)
+    end
+
+    it "doesn't do anything without a transaction" do
+      on_start
+
+      request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = nil
+
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "action" => nil,
+        "sample_data" => {},
+        "events" => []
+      )
+    end
+
+    it "completes the transaction" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        # The action is not set on purpose, as we can't set a normalized route
+        # It requires the app to set an action name
+        "action" => nil,
+        "sample_data" => hash_including(
+          "environment" => {
+            "REQUEST_METHOD" => "GET",
+            "PATH_INFO" => "/path"
+          }
+        )
+      )
+      expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+    end
+
+    it "doesn't set the action name if already set" do
+      on_start
+      last_transaction.set_action("My action")
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "action" => "My action"
+      )
+    end
+
+    it "finishes the process_request.rack event" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "events" => [
+          hash_including(
+            "name" => "process_request.rack",
+            "title" => "",
+            "body" => "",
+            "body_format" => Appsignal::EventFormatter::DEFAULT
+          )
+        ]
+      )
+    end
+
+    it "sets the response status as a tag" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "sample_data" => hash_including(
+          "tags" => { "response_status" => 200 }
+        )
+      )
+    end
+
+    it "increments the response status counter for response status" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with(:response_status, 1, :status => 200, :namespace => :web)
+
+      on_start
+      on_finish
+    end
+
+    it "logs an error in case of an error" do
+      expect(Appsignal::Transaction)
+        .to receive(:complete_current!).and_raise(ExampleStandardError, "oh no")
+
+      on_start
+      on_finish
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no"
+      )
+    end
+  end
+end

data/spec/lib/appsignal/rack/rails_instrumentation_spec.rb

@@ -1,14 +1,21 @@
 if DependencyHelper.rails_present?
-  class MockController
-  end
-
   describe Appsignal::Rack::RailsInstrumentation do
+    class MockController; end
+
     let(:log) { StringIO.new }
     before do
       start_agent
       Appsignal.internal_logger = test_logger(log)
     end
 
+    let(:transaction) do
+      Appsignal::Transaction.new(
+        "transaction_id",
+        Appsignal::Transaction::HTTP_REQUEST,
+        Rack::Request.new(env)
+      )
+    end
+    let(:app) { double(:call => true) }
     let(:params) do
       {
         "controller" => "blog_posts",
@@ -19,12 +26,11 @@ if DependencyHelper.rails_present?
       }
     end
     let(:env_extra) { {} }
-    let(:app) { double(:call => true) }
     let(:env) do
       http_request_env_with_data({
         :params => params,
         :with_queue_start => true,
-        "action_dispatch.request_id" => "1",
+        "action_dispatch.request_id" => "request_id123",
         "action_dispatch.parameter_filter" => [:my_custom_param, :password],
         "action_controller.instance" => double(
           :class => MockController,
@@ -34,6 +40,9 @@ if DependencyHelper.rails_present?
     end
     let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
     around { |example| keep_transactions { example.run } }
+    before do
+      env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
+    end
 
     describe "#call" do
       before do
@@ -43,7 +52,7 @@ if DependencyHelper.rails_present?
       context "when appsignal is active" do
         before { allow(Appsignal).to receive(:active?).and_return(true) }
 
-        it "should call with monitoring" do
+        it "calls with monitoring" do
           expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
         end
       end
@@ -51,11 +60,11 @@ if DependencyHelper.rails_present?
       context "when appsignal is not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
-        it "should not call with monitoring" do
+        it "does not call with monitoring" do
           expect(middleware).to_not receive(:call_with_appsignal_monitoring)
         end
 
-        it "should call the app" do
+        it "calls the app" do
           expect(app).to receive(:call).with(env)
         end
       end
@@ -66,36 +75,34 @@ if DependencyHelper.rails_present?
     describe "#call_with_appsignal_monitoring" do
       def run
         middleware.call(env)
+        last_transaction.complete # Manually close transaction to set sample data
       end
 
       it "calls the wrapped app" do
-        run
+        expect { run }.to_not(change { created_transactions.length })
         expect(app).to have_received(:call).with(env)
       end
 
-      it "creates one transaction with metadata" do
+      it "sets request metadata on the transaction" do
         run
 
-        expect(created_transactions.length).to eq(1)
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash).to include(
+        expect(last_transaction.to_h).to include(
           "namespace" => Appsignal::Transaction::HTTP_REQUEST,
           "action" => "MockController#index",
           "metadata" => hash_including(
             "method" => "GET",
             "path" => "/blog"
+          ),
+          "sample_data" => hash_including(
+            "tags" => { "request_id" => "request_id123" }
           )
         )
-        expect(last_transaction.ext.queue_start).to eq(
-          fixed_time * 1_000.0
-        )
       end
 
-      it "filter parameters in Rails" do
+      it "reports Rails filter parameters" do
         run
 
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash).to include(
+        expect(last_transaction.to_h).to include(
           "sample_data" => hash_including(
             "params" => params.merge(
               "my_custom_param" => "[FILTERED]",
@@ -105,6 +112,26 @@ if DependencyHelper.rails_present?
         )
       end
 
+      context "with custom params" do
+        let(:app) do
+          lambda do |env|
+            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].params = { "custom_param" => "yes" }
+          end
+        end
+
+        it "allows custom params to be set" do
+          run
+
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_including(
+              "params" => {
+                "custom_param" => "yes"
+              }
+            )
+          )
+        end
+      end
+
       context "with an invalid HTTP request method" do
         let(:env_extra) { { :request_method => "FOO", "REQUEST_METHOD" => "FOO" } }
 
@@ -113,8 +140,8 @@ if DependencyHelper.rails_present?
 
           transaction_hash = last_transaction.to_h
           expect(transaction_hash["metadata"]).to_not have_key("method")
-          expect(log_contents(log)).to contains_log(:error,
-            "Unable to report HTTP request method: '")
+          expect(log_contents(log))
+            .to contains_log(:error, "Unable to report HTTP request method: '")
         end
       end
 
@@ -137,25 +164,32 @@ if DependencyHelper.rails_present?
           )
         end
       end
-    end
 
-    describe "#request_id" do
-      subject { middleware.request_id(env) }
+      context "with a request path that's not a route" do
+        let(:env_extra) do
+          {
+            :path => "/unknown-route",
+            "action_controller.instance" => nil
+          }
+        end
 
-      context "with request id present" do
-        let(:env) { { "action_dispatch.request_id" => "id" } }
+        it "doesn't set an action name" do
+          run
 
-        it "returns the present id" do
-          is_expected.to eq "id"
+          expect(last_transaction.to_h).to include(
+            "action" => nil
+          )
         end
       end
+    end
 
-      context "with request id not present" do
-        let(:env) { {} }
+    describe "#fetch_request_id" do
+      subject { middleware.fetch_request_id(env) }
 
-        it "sets a new id" do
-          expect(subject.length).to eq 36
-        end
+      let(:env) { { "action_dispatch.request_id" => "id" } }
+
+      it "returns the action dispatch id" do
+        is_expected.to eq "id"
       end
     end
   end

data/spec/lib/appsignal/transaction_spec.rb

@@ -719,7 +719,6 @@ describe Appsignal::Transaction do
 
         sample_data = transaction.to_h["sample_data"]
         expect(sample_data["environment"]).to include(
-          "CONTENT_LENGTH" => "0",
           "REQUEST_METHOD" => "GET",
           "SERVER_NAME" => "example.org",
           "SERVER_PORT" => "80",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.7.5
+  version: 3.8.1
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-14 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -135,6 +135,7 @@ extra_rdoc_files: []
 files:
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/chore.md"
+- ".github/workflows/create_release_from_tag.yml"
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
@@ -208,6 +209,7 @@ files:
 - lib/appsignal/extension/jruby.rb
 - lib/appsignal/garbage_collection.rb
 - lib/appsignal/heartbeat.rb
+- lib/appsignal/helpers/heartbeats.rb
 - lib/appsignal/helpers/instrumentation.rb
 - lib/appsignal/helpers/metrics.rb
 - lib/appsignal/hooks.rb
@@ -269,6 +271,7 @@ files:
 - lib/appsignal/probes/helpers.rb
 - lib/appsignal/probes/mri.rb
 - lib/appsignal/probes/sidekiq.rb
+- lib/appsignal/rack/event_handler.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/rails_instrumentation.rb
 - lib/appsignal/rack/sinatra_instrumentation.rb
@@ -369,6 +372,7 @@ files:
 - spec/lib/appsignal/probes/mri_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/probes_spec.rb
+- spec/lib/appsignal/rack/event_handler_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
 - spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb
@@ -454,7 +458,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com