appsignal 4.10.4-java → 5.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9130a7fa45f49f8047af34f7fe483456fedef973f9e62ca56bdaad50eb3a1f
-  data.tar.gz: f7b4bf9aac46c183ce5ff78387e7a4ab56f85f203efcf2f995701d5424517c7c
+  metadata.gz: aa6ecd3d80cea2a3d5b0f3e00c40b3248c633e352337a4640843e7255fc84c49
+  data.tar.gz: 98d1d112ded643cc555d7e54b1dd14d3a4d564db310386383e772b298697ba4d
 SHA512:
-  metadata.gz: d044269ce96bcbef0e9400ee611b41ee762d529ed0f802451974df77576ad27f46e47465f0f66cceae099a2fa34b361f63267c3182eb351d3b2d31ef108bfcbd
-  data.tar.gz: e3040b1ad97a20dbfe94fe80345489a22d8de81c907df61180d5e247553122c92dcd146be3b7b37cb665b6db28d454bf580e1e05345e52a61270da31d6774360
+  metadata.gz: dd8c19f24a975e360e54d133ab29ec6b8143663e2f55acc97f2f3b7b0556db527188beb808259fb427faa9e3b055036deec2c7bc0f9163db0abcee3503e42756
+  data.tar.gz: b727d0b3c91e179f332b198107d0bb8b4ab2bcfab929483b017744cd57746b5d2291674447d317fe305856e05df583af2d07bf7a9d61f329bbccc9f806e8beab

data/CHANGELOG.md

@@ -1,5 +1,80 @@
 # AppSignal for Ruby gem Changelog
 
+## 5.0.0
+
+_Published on 2026-09-28._
+
+### Changed
+
+- Release the final package version. See the pre-release changelog entries for the changes in this version. (major)
+
+## 5.0.0.rc.2
+
+_Published on 2026-09-23._
+
+This release also includes all the changes from AppSignal for Ruby version 4.10.4 and below.
+
+### Added
+
+- Detect the revision that is being deployed from the environment variables set by Heroku, Render, Kamal and Scalingo: `HEROKU_SLUG_COMMIT`, `RENDER_GIT_COMMIT`, `KAMAL_VERSION` and `CONTAINER_VERSION`. Applications deployed on those platforms now report their revision without setting the `revision` configuration option.
+
+  This affects collector mode, where deploys were reported as `unknown` when the revision was not configured.
+
+  (patch [bf606432](https://github.com/appsignal/appsignal-ruby/commit/bf606432aab96d3f9b3a20cbb4b0c48aa7748702))
+- Detect the hostname of the machine the application runs on. On Heroku this is the name of the dyno, and everywhere else it is the name the host reports for itself. Set the `hostname` configuration option to report a different name.
+
+  This affects collector mode, where all data was reported for a host named `unknown` when the hostname was not configured.
+
+  (patch [bf606432](https://github.com/appsignal/appsignal-ruby/commit/bf606432aab96d3f9b3a20cbb4b0c48aa7748702))
+- Report the host, the port and the HTTP version of an incoming web request in collector mode. These are sent as the `server.address`, `server.port` and `network.protocol.version` OpenTelemetry attributes. The host is read from the `Forwarded` and `X-Forwarded-Host` headers when a proxy sets them, so it is the host the client used rather than the one the proxy connected to. (patch [85460ff3](https://github.com/appsignal/appsignal-ruby/commit/85460ff3d8ae5235515fe291b9a6baea6ad0c47c))
+- Report the request environment in collector mode. The `request_headers` configuration option is an allowlist of Rack environment names, and some of those names are not request headers. Those values are now reported as `appsignal.environment.*` OpenTelemetry attributes and shown in the request's Environment panel, instead of being left out.
+
+  Values that describe the request itself are not repeated there, because they are already reported as the request's method, path, host, port and protocol version.
+
+  (patch [85460ff3](https://github.com/appsignal/appsignal-ruby/commit/85460ff3d8ae5235515fe291b9a6baea6ad0c47c))
+- Add the `keep_request_headers` and `keep_request_environment` configuration options, which are used in collector mode. They replace `request_headers`, which is deprecated in collector mode.
+
+  `keep_request_headers` lists the request headers to report, using the names OpenTelemetry uses for them, such as `accept` and `content-length`. `keep_request_environment` lists the Rack environment values to report that are not request headers, using the names Rack uses for them, such as `REMOTE_ADDR`.
+
+  Both options default to a value derived from `request_headers`, which lists Rack environment keys and mixes the two kinds together. So an application that only ever set `request_headers` keeps reporting the same values when it moves to collector mode.
+
+  The `request_headers` configuration option is deprecated in collector mode, and a warning will be emitted at startup, containing the values of `keep_request_headers` and `keep_request_environment` that should be used to replace it.
+
+  In agent mode, `request_headers` still lists every Rack environment key to report, and the two new options have no effect.
+
+  (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+- Add the `Appsignal.add_request_headers` and `Appsignal.add_request_environment` helpers.
+
+  Use `add_request_headers` to report request headers, naming each header in lowercase and with dashes, such as `content-length`. Use `add_request_environment` to report the values a Rack environment holds that are not request headers, naming each one the way Rack names it, such as `REMOTE_ADDR`.
+
+  In agent mode, both write to the "Environment" sample data, formatted as Rack environment keys. In collector mode, they write different span attributes.
+
+  Together they replace `Appsignal.add_headers`, which is now deprecated, as it accepts Rack environment keys and works out which ones are headers.
+
+  (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+- Report request headers for Webmachine applications. (patch [fcfb7a0d](https://github.com/appsignal/appsignal-ruby/commit/fcfb7a0d2545a2144aa61efa61d445c0e11c7749), [b47f5bd2](https://github.com/appsignal/appsignal-ruby/commit/b47f5bd2b4611f5a6089bff28f91d47eac94422f), [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+
+### Changed
+
+- Report `app` instead of `unknown` as the OpenTelemetry service name when the `service_name` configuration option is not set and collector mode is in use. (patch [7078181c](https://github.com/appsignal/appsignal-ruby/commit/7078181ccfc5aa5bb1200d99aa7c612c5acbbd00))
+- The `filter_parameters` and `send_params` configuration options are deprecated in collector mode. Use `filter_request_payload`, `filter_function_parameters` and `filter_request_query_parameters` to filter different kinds of parameters, and `send_request_payload`, `send_request_query_parameters` and `send_function_parameters` to choose which kinds of parameters to report.
+
+  In collector mode, each kind of parameter is now filtered and reported according to its own options, and the deprecated options' values are only used to fill in values when the new options are unset. AppSignal logs which values to set to keep reporting what it reports now.
+
+  In agent mode, `filter_parameters` and `send_params` still apply to every kind of parameter, and the new options have no effect.
+
+  (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+
+### Fixed
+
+- The `ignore_logs` option now filters out the log lines that match its patterns in collector mode. (patch [bf606432](https://github.com/appsignal/appsignal-ruby/commit/bf606432aab96d3f9b3a20cbb4b0c48aa7748702))
+- In collector mode, backtrace lines from your own application are now shown as paths relative to your application's root, and are recognized as your application's code. (patch [bf606432](https://github.com/appsignal/appsignal-ruby/commit/bf606432aab96d3f9b3a20cbb4b0c48aa7748702))
+- The `ca_file_path` and `http_proxy` options now apply to the data sent to the collector in collector mode. Before this change they only applied to the data sent by the agent, so a custom certificate authority file or a proxy had no effect in collector mode. (patch [e99c6b68](https://github.com/appsignal/appsignal-ruby/commit/e99c6b689b20fb433ecdcdc9fb8c6173e1ea8cda))
+- Remove an incorrect warning about the `filter_metadata` configuration option being ignored in collector mode. (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+- Report request headers in collector mode. (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+- Report no response headers in collector mode until the `response_headers` configuration option names some. The option had no effect at all, so every response header captured by the application's own OpenTelemetry instrumentation was reported whatever the option said. (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+- Read an array configuration option written as a null in `config/appsignal.yml` as the empty list it means. Options such as `filter_parameters` and `ignore_actions` raised a `NoMethodError` when AppSignal started, and `filter_metadata` and `filter_session_data` raised one while a transaction was sampled. (patch [992a60c8](https://github.com/appsignal/appsignal-ruby/commit/992a60c8d0f68b3edcb00150a1e9f14985619a4f))
+
 ## 4.10.4
 
 _Published on 2026-09-22._
@@ -27,6 +102,20 @@ _Published on 2026-09-10._
 
   (patch [74f509b0](https://github.com/appsignal/appsignal-ruby/commit/74f509b0e8438140bab79a5189c2ed421bbbdf6d))
 
+## 3.13.2
+
+_Published on 2026-09-09._
+
+### Changed
+
+- Update the agent to handle high traffic apps. On high-traffic apps that would exceed the maximum accepted internal payload size, send data to the Push API more frequently. (patch [c69fbf57](https://github.com/appsignal/appsignal-ruby/commit/c69fbf57242b13c86af2196baae8f295285de947))
+- Update the agent from version 0.35.19 to version 0.37.0. The 3.x series of the Ruby gem was several agent releases behind, so this update also brings the improvements from every agent release in between. Those include better sanitisation of SQL queries, host metric collection that keeps working when a disk mount is frozen, and no more leftover `[timeout]` processes on Alpine Linux containers. (patch [c69fbf57](https://github.com/appsignal/appsignal-ruby/commit/c69fbf57242b13c86af2196baae8f295285de947))
+
+### Fixed
+
+- Fix events showing as unknown in long-running applications. An application process that kept running for thirty days without restarting could lose the names and queries of the events it recorded, both in slow traces and in the "Slow events" panel. (patch [c69fbf57](https://github.com/appsignal/appsignal-ruby/commit/c69fbf57242b13c86af2196baae8f295285de947))
+- Prevent `gc` events from appearing in the "Slow events" panel. (patch [c69fbf57](https://github.com/appsignal/appsignal-ruby/commit/c69fbf57242b13c86af2196baae8f295285de947))
+
 ## 4.10.2
 
 _Published on 2026-09-09._
@@ -75,6 +164,25 @@ _Published on 2026-09-09._
 
   (patch [fe82dc60](https://github.com/appsignal/appsignal-ruby/commit/fe82dc60bc8b52d466c0c9b673adbae29f79449e))
 
+## 5.0.0.rc.1
+
+_Published on 2026-08-21._
+
+### Added
+
+- Add a `collector_endpoint` configuration option (`APPSIGNAL_COLLECTOR_ENDPOINT` environment variable) that puts the integration in _collector mode_. In collector mode AppSignal reports traces, metrics and logs to an AppSignal Collector, over OTLP/HTTP.
+
+  Collector mode requires Ruby 3.1 or newer, and the OpenTelemetry gems, which are not installed by default. Add the `appsignal-opentelemetry` gem alongside `appsignal` to install them. When they are missing or too old, AppSignal logs a warning and keeps reporting through its agent.
+
+  (major [84d83b65](https://github.com/appsignal/appsignal-ruby/commit/84d83b657d65a93859ba73f295216a3b0ee9cab1), [90768626](https://github.com/appsignal/appsignal-ruby/commit/9076862677444c7772e6f8fbe1e3d5a646a4849d))
+- Add configuration options that map to OpenTelemetry resource attributes in collector mode: `service_name`, `filter_attributes`, `filter_function_parameters`, `filter_request_query_parameters`, `filter_request_payload`, `response_headers`, `send_function_parameters`, `send_request_query_parameters` and `send_request_payload`.
+
+  In collector mode, existing options are passed to the collector as resource attributes as well: `name`, environment, `hostname`, `revision`, `ignore_actions`, `ignore_errors`, `ignore_namespaces`, `request_headers`, `filter_session_data` and `send_session_data`.
+
+  Setting any of these without `collector_endpoint`, or setting `filter_parameters`, `filter_metadata` or `send_params` with it, logs a warning at startup.
+
+  (minor [84d83b65](https://github.com/appsignal/appsignal-ruby/commit/84d83b657d65a93859ba73f295216a3b0ee9cab1), [90768626](https://github.com/appsignal/appsignal-ruby/commit/9076862677444c7772e6f8fbe1e3d5a646a4849d))
+
 ## 4.10.1
 
 _Published on 2026-08-20._

data/Rakefile

@@ -20,6 +20,8 @@ VERSION_MANAGERS = {
   }
 }.freeze
 
+SPEC_COVERAGE_AUDIT_JOB_NAME = "Spec coverage audit"
+
 def build_job(ruby_version, ruby_gem: nil, runs_on: DEFAULT_RUNS_ON)
   name = "Ruby #{ruby_version}"
   name = "#{name} - #{ruby_gem}" if ruby_gem
@@ -57,6 +59,89 @@ def build_job(ruby_version, ruby_gem: nil, runs_on: DEFAULT_RUNS_ON)
   }
 end
 
+# Every test job uploads the example list its run wrote, named after the job so
+# the audit can say which combination is missing one. Uploaded even when the run
+# fails, because the list is written either way and the audit needs to tell a
+# crashed job apart from a combination that legitimately runs nothing.
+def example_list_upload_step(key)
+  {
+    "name" => "Upload example list",
+    "if" => "always()",
+    "uses" => "actions/upload-artifact@v4",
+    "with" => {
+      "name" => key,
+      "path" => "tmp/examples-*.json",
+      "if-no-files-found" => "error",
+      "retention-days" => 1
+    }
+  }
+end
+
+# Compares the examples defined in the source against the union of every job's
+# example list.
+#
+# It cannot wait for the test jobs through `needs`. Naming all 426 of them puts
+# the workflow over a limit on how many dependency edges GitHub accepts, and
+# GitHub then refuses to create the run without reporting anything: no run
+# appears, the pull request shows no checks, and the runs API stays empty.
+# Grouping the dependencies behind intermediate jobs does not help, because the
+# same number of edges still has to exist. So this job starts with the others
+# and waits by polling the run it belongs to.
+def spec_coverage_audit_job
+  {
+    "name" => SPEC_COVERAGE_AUDIT_JOB_NAME,
+    "needs" => "validation",
+    "runs-on" => DEFAULT_RUNS_ON,
+    # Reports without failing the build. The examples it currently finds are
+    # covered by separate work; removing this line is what makes it enforcing.
+    "continue-on-error" => true,
+    # Long enough for the whole matrix, and short enough that a stuck job does
+    # not hold a runner for the six hours GitHub would otherwise allow.
+    "timeout-minutes" => 180,
+    "permissions" => {
+      "actions" => "read",
+      "contents" => "read"
+    },
+    "steps" => [
+      {
+        "name" => "Check out repository",
+        "uses" => "actions/checkout@v4"
+      },
+      {
+        "name" => "Install Ruby",
+        "uses" => "ruby/setup-ruby@v1",
+        "with" => { "ruby-version" => "3.4" }
+      },
+      {
+        "name" => "Wait for the test jobs to upload their example lists",
+        "env" => { "GH_TOKEN" => "${{ secrets.GITHUB_TOKEN }}" },
+        "run" => <<~SHELL
+          jobs="repos/${{ github.repository }}/actions/runs/${{ github.run_id }}/jobs"
+          filter='.jobs[]
+            | select(.name != "#{SPEC_COVERAGE_AUDIT_JOB_NAME}")
+            | select(.status != "completed")
+            | .name'
+          while :; do
+            pending=$(gh api --paginate "$jobs?per_page=100" --jq "$filter" | wc -l)
+            if [ "$pending" -eq 0 ]; then break; fi
+            echo "Waiting for $pending jobs."
+            sleep 60
+          done
+        SHELL
+      },
+      {
+        "name" => "Download example lists",
+        "uses" => "actions/download-artifact@v4",
+        "with" => { "path" => "artifacts" }
+      },
+      {
+        "name" => "Audit spec coverage",
+        "run" => "ruby script/audit_spec_coverage.rb artifacts"
+      }
+    ]
+  }
+end
+
 def build_matrix_key(ruby_version, ruby_gem: nil, runs_on: DEFAULT_RUNS_ON)
   base = "ruby_#{ruby_version}"
   base = "#{base}__#{ruby_gem}" if ruby_gem
@@ -72,7 +157,50 @@ GITHUB_ACTION_WORKFLOW_FILE = ".github/workflows/ci.yml"
 PRIMARY_JOB_GEMSET = "no_dependencies"
 DEFAULT_RUNS_ON = "ubuntu-latest"
 
+COLLECTOR_GEMFILE_PARTIAL = "collector.rb"
+
 namespace :build_matrix do
+  namespace :gemfiles do
+    # Generates a `<base>-collector.gemfile` next to each base gemfile. The
+    # variant layers the optional OpenTelemetry gems (`gemfiles/collector.rb`)
+    # on top of the base, so collector-mode test runs resolve them while the
+    # base gemfiles (and the gemspec) stay OpenTelemetry-free. Regenerate
+    # whenever a base gemfile is added or removed.
+    task :generate do
+      base_gemfiles =
+        Dir["gemfiles/*.gemfile"]
+          .map { |path| File.basename(path) }
+          .reject { |name| name.end_with?("-collector.gemfile") }
+          .sort
+
+      base_gemfiles.each do |base|
+        name = base.sub(/\.gemfile\z/, "")
+        contents =
+          "# DO NOT EDIT\n" \
+            "# This is a generated file by the " \
+            "`rake build_matrix:gemfiles:generate` task.\n" \
+            "# It layers the optional OpenTelemetry gems (gemfiles/" \
+            "#{COLLECTOR_GEMFILE_PARTIAL}) on top of #{base}.\n" \
+            "\n" \
+            "eval_gemfile File.expand_path(#{base.inspect}, __dir__)\n" \
+            "eval_gemfile File.expand_path(" \
+            "#{COLLECTOR_GEMFILE_PARTIAL.inspect}, __dir__)\n"
+        File.write("gemfiles/#{name}-collector.gemfile", contents)
+      end
+
+      puts "Generated #{base_gemfiles.count} `-collector` gemfiles."
+    end
+
+    task :validate => :generate do
+      output = `git status --porcelain gemfiles`
+      if output.include?("-collector.gemfile")
+        puts "The `-collector` gemfiles are out of date. The changes were not committed."
+        puts "Please run `rake build_matrix:gemfiles:generate` and commit the changes."
+        exit 1
+      end
+    end
+  end
+
   namespace :github do
     task :generate do
       yaml = YAML.load_file("build_matrix.yml")
@@ -107,12 +235,31 @@ namespace :build_matrix do
               "name" => "Run tests without extension",
               "run" => "./script/bundler_wrapper exec rake test:failure"
             }
+            job["steps"] << example_list_upload_step(build_matrix_key(ruby["ruby"]))
             builds[build_matrix_key(ruby["ruby"])] = job
           else
             job["needs"] = build_matrix_key(ruby["ruby"])
             job["steps"] << test_step
-            builds[build_matrix_key(ruby["ruby"], :ruby_gem => ruby_gem["gem"])] = job
+            gem_key = build_matrix_key(ruby["ruby"], :ruby_gem => ruby_gem["gem"])
+            job["steps"] << example_list_upload_step(gem_key)
+            builds[gem_key] = job
           end
+
+          # On collector-capable Rubies, additionally run the gem's
+          # `-collector` gemfile (base gems + optional OpenTelemetry gems) so
+          # collector-mode specs are exercised. These always depend on the
+          # primary job for the Ruby version and run on Ubuntu only.
+          next unless collector_ruby?(matrix, ruby_version)
+
+          collector_gem = "#{ruby_gem["gem"]}-collector"
+          collector_job = build_job(ruby_version, :ruby_gem => collector_gem)
+          collector_job["env"] = matrix["env"]
+            .merge("BUNDLE_GEMFILE" => "gemfiles/#{collector_gem}.gemfile")
+          collector_job["needs"] = build_matrix_key(ruby["ruby"])
+          collector_job["steps"] << test_step
+          collector_key = build_matrix_key(ruby["ruby"], :ruby_gem => collector_gem)
+          collector_job["steps"] << example_list_upload_step(collector_key)
+          builds[collector_key] = collector_job
         end
 
         # Add build for macOS
@@ -130,9 +277,13 @@ namespace :build_matrix do
           "name" => "Run tests without extension",
           "run" => "./script/bundler_wrapper exec rake test:failure"
         }
-        builds[build_matrix_key(ruby["ruby"], :runs_on => runs_on)] = job
+        macos_key = build_matrix_key(ruby["ruby"], :runs_on => runs_on)
+        job["steps"] << example_list_upload_step(macos_key)
+        builds[macos_key] = job
       end
 
+      builds["spec_coverage_audit"] = spec_coverage_audit_job
+
       github["jobs"] = github["jobs"].merge(builds)
 
       job_count = github["jobs"].count
@@ -191,6 +342,14 @@ namespace :build_matrix do
             out << "#{bundler_version} #{gemfile_env} ./script/bundler_wrapper install --quiet || { echo 'Bundling failed'; exit 1; }"
             out << "echo 'Running #{gemfile} in #{ruby_version}'"
             out << "#{bundler_version} #{gemfile_env} ./script/bundler_wrapper exec rspec || { echo 'Running specs failed'; exit 1; }"
+
+            next unless collector_ruby?(matrix, ruby_version)
+
+            collector_env = "env BUNDLE_GEMFILE=gemfiles/#{gemfile}-collector.gemfile"
+            out << "echo 'Bundling #{gemfile}-collector in #{ruby_version}'"
+            out << "#{bundler_version} #{collector_env} ./script/bundler_wrapper install --quiet || { echo 'Bundling failed'; exit 1; }"
+            out << "echo 'Running #{gemfile}-collector in #{ruby_version}'"
+            out << "#{bundler_version} #{collector_env} ./script/bundler_wrapper exec rspec || { echo 'Running specs failed'; exit 1; }"
           end
           # rubocop:enable Layout/LineLength
           out << ""
@@ -207,6 +366,10 @@ namespace :build_matrix do
     end
   end
 
+  def collector_ruby?(matrix, ruby_version)
+    Array(matrix.dig("collector", "ruby")).include?(ruby_version)
+  end
+
   def gemset_for_ruby(ruby, matrix)
     gems = matrix["gems"]
     if ruby["gems"]
@@ -288,6 +451,23 @@ namespace :build do
   desc "Build all gem versions"
   task :all => ["ruby:gem", "jruby:gem"]
 
+  desc "Build every package in this repository"
+  task :packages => :all do
+    # Build the companion gem by delegating to its own Rakefile rather than
+    # duplicating its build logic here. mono builds each package directly, so
+    # this task is only a convenience for developers building from the root.
+    #
+    # Clear the Bundler environment first so the sub-build resolves against the
+    # package's own Gemfile instead of inheriting this repository's
+    # BUNDLE_GEMFILE. Install its dependencies first, then build it.
+    Bundler.with_unbundled_env do
+      Dir.chdir("packages/opentelemetry") do
+        sh "bundle install"
+        sh "bundle exec rake build:all"
+      end
+    end
+  end
+
   desc "Clean up all gem build artifacts"
   task :clean do
     FileUtils.rm_rf File.expand_path("pkg", __dir__)
@@ -361,14 +541,25 @@ begin
   excludes << "spec/lib/appsignal/extension/jruby_spec.rb" unless is_jruby
   exclude_pattern = "--exclude-pattern=#{excludes.join(",")}" if excludes.any?
 
+  # Written alongside the human-readable output so the coverage audit can tell
+  # which examples this Ruby and gemfile combination actually ran. Every CI job
+  # uploads its list. Nothing else reveals that a dependency guard is false in
+  # every combination, because a guarded example is then never defined at all.
+  def example_list_opts(name)
+    "--format json --out tmp/examples-#{name}.json"
+  end
+
   desc "Run the AppSignal gem test suite."
   RSpec::Core::RakeTask.new :test do |t|
-    t.rspec_opts = "#{exclude_pattern} --format documentation"
+    t.rspec_opts = "#{exclude_pattern} --format documentation " \
+      "#{example_list_opts("test")}"
   end
 
   namespace :test do
     RSpec::Core::RakeTask.new :rspec_failure do |t|
-      t.rspec_opts = "#{exclude_pattern} --tag extension_installation_failure"
+      t.rspec_opts = "#{exclude_pattern} --format documentation " \
+        "--tag extension_installation_failure " \
+        "#{example_list_opts("failure")}"
     end
 
     desc "Intentionally fail the extension installation"

data/appsignal.gemspec

@@ -7,6 +7,7 @@ IGNORED_PATHS = [
   ".changesets/",
   ".github/",
   "gemfiles/",
+  "packages/",
   "script/",
   "spec/",
 
@@ -60,6 +61,13 @@ Gem::Specification.new do |gem|
   # Needs 2.0+ because we rely on Rack::Events
   gem.add_dependency "rack", ">= 2.0.0"
 
+  # The OpenTelemetry SDK and OTLP exporters are *optional* and intentionally
+  # not declared here: they're only needed in collector mode (Ruby 3.1+), so
+  # bundling them would break Ruby 2.7 and burden non-collector users. Apps
+  # that enable collector mode add them to their own Gemfile; the minimum
+  # versions live in `lib/appsignal/opentelemetry/dependencies.rb` and are
+  # enforced at boot by `Appsignal::OpenTelemetry.configure`.
+
   gem.add_development_dependency "pry"
   # Reached through webmock's addressable. Version 7 requires Ruby 3.2 and
   # version 6 requires 3.0, so an older Ruby cannot resolve the development

data/build_matrix.yml

@@ -107,6 +107,18 @@ matrix:
     JRUBY_OPTS: ""
     COV: "1"
 
+  # Ruby versions that additionally run each gem's `-collector` gemfile (the
+  # optional OpenTelemetry gems layered on top). Collector mode requires Ruby
+  # 3.1+ (the OTel metrics SDK's fork hooks rely on `Process._fork`) and does
+  # not support JRuby's forking model, so only these versions are listed.
+  collector:
+    ruby:
+      - "4.0.0"
+      - "3.4.1"
+      - "3.3.4"
+      - "3.2.5"
+      - "3.1.6"
+
   gemsets: # By default all gems are tested
     none:
       - "no_dependencies"

data/ext/appsignal_extension.c

@@ -834,10 +834,23 @@ static VALUE add_distribution_value(VALUE self, VALUE key, VALUE value, VALUE ta
   return Qnil;
 }
 
+// Per-thread running total of object allocations, incremented on every Ruby
+// NEWOBJ event. Thread-local because MRI maps each Ruby thread to its own OS
+// thread, so this attributes allocations to the thread doing the work, which is
+// the thread the transaction runs on. Collector mode reads it through
+// Appsignal::Extension.allocation_count and diffs two snapshots to get the
+// allocations made during a transaction or an event.
+static __thread unsigned long long appsignal_thread_allocation_count = 0;
+
 static void track_allocation(rb_event_flag_t flag, VALUE arg1, VALUE arg2, ID arg3, VALUE arg4) {
+  appsignal_thread_allocation_count++;
   appsignal_track_allocation();
 }
 
+static VALUE allocation_count(VALUE self) {
+  return ULL2NUM(appsignal_thread_allocation_count);
+}
+
 static VALUE install_allocation_event_hook(VALUE self) {
   // This event hook is only available on Ruby 2.1 and 2.2
   #if defined(RUBY_INTERNAL_EVENT_NEWOBJ)
@@ -956,6 +969,7 @@ void Init_appsignal_extension(void) {
 
   // Other helper methods
   rb_define_singleton_method(Extension, "install_allocation_event_hook", install_allocation_event_hook, 0);
+  rb_define_singleton_method(Extension, "allocation_count", allocation_count, 0);
   rb_define_singleton_method(Extension, "running_in_container?", running_in_container, 0);
   rb_define_singleton_method(Extension, "set_environment_metadata", set_environment_metadata, 2);
 

data/lib/appsignal/backends.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "appsignal/metrics/extension_backend"
+require "appsignal/metrics/opentelemetry_backend"
+require "appsignal/logger/extension_backend"
+require "appsignal/logger/opentelemetry_backend"
+require "appsignal/transaction/base_backend"
+require "appsignal/transaction/extension_backend"
+require "appsignal/transaction/opentelemetry_backend"
+
+module Appsignal
+  # @!visibility private
+  #
+  # Looks up the active backend for each AppSignal subsystem. In normal
+  # operation, subsystems route through the C-extension (and its agent).
+  # When collector mode is configured and the OpenTelemetry SDK has booted
+  # successfully, supported subsystems route through OTel instead.
+  #
+  # Centralizes the mode-check so per-subsystem call sites don't repeat the
+  # "if collector? then OTel else Extension" branch. Future subsystems plug
+  # in by adding one more lookup method here.
+  module Backends
+    class << self
+      def metrics
+        if collector?
+          Appsignal::Metrics::OpenTelemetryBackend
+        else
+          Appsignal::Metrics::ExtensionBackend
+        end
+      end
+
+      def logger
+        if collector?
+          Appsignal::Logger::OpenTelemetryBackend
+        else
+          Appsignal::Logger::ExtensionBackend
+        end
+      end
+
+      def transaction
+        if collector?
+          Appsignal::Transaction::OpenTelemetryBackend
+        else
+          Appsignal::Transaction::ExtensionBackend
+        end
+      end
+
+      private
+
+      def collector?
+        Appsignal.config&.collector_mode? || false
+      end
+    end
+  end
+end

data/lib/appsignal/cli/diagnose.rb

@@ -201,6 +201,7 @@ module Appsignal
 
           # No config loaded yet, try loading as normal
           Appsignal._load_config!(env_option) unless Appsignal.config
+          Appsignal.config.apply_overrides
           Appsignal._start_logger
           Appsignal.config.write_to_environment
           Appsignal.internal_logger.info("Starting AppSignal diagnose")
@@ -472,16 +473,7 @@ module Appsignal
           config = Appsignal.config
           data[:config] = {
             :options => config.config_hash.merge(:env => config.env),
-            :sources => {
-              :default => Appsignal::Config::DEFAULT_CONFIG,
-              :system => config.system_config,
-              :loaders => config.loaders_config,
-              :initial => config.initial_config,
-              :file => config.file_config,
-              :env => config.env_config,
-              :override => config.override_config,
-              :dsl => config.dsl_config
-            }
+            :sources => config.config_sources
           }
           print_config_options(config)
         end