appsignal 3.10.0 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4767b1d66b7aa4d47b79e83265b1e2631b9733f730e392b109d9d563013c79
-  data.tar.gz: 231bc55dfcd8084175fb505470b266937363de1e833852dd539d2970aad36d22
+  metadata.gz: c2cfb956b5058ae48109ce92cc65f4158f472797f531579e63aeb8398cb73044
+  data.tar.gz: 34ba16eb3b7c3b464e10fb9a8533d3b230cfb73550f6a804599e02b96fb909f1
 SHA512:
-  metadata.gz: 3116383c605eb524838419ca4911ad2a06ef2b2289d1b88705107c51595edcc749270fa824bc79552c6e255524409630ab477fd9fd6ab72fabf3e7a9ebd6025a
-  data.tar.gz: 471f59339ae58c4a45bcad29560e04397dd646efa7b9269167ed142c773c92018e2e34288d931c14c2a4ec3045f068f760e687179034464a8dda3001fb689244
+  metadata.gz: e374e9fc6cb686ec6297cb9f8025a6309f011dfc8fff3c22f32f8ddb9635e867dfd001e7058553a3f2d624bf68065e2efe2f69e73692d9b05195736992d6af63
+  data.tar.gz: e83be1622f1c5d86748bc3bb93912d79ac2dd66cb6bbe61106aee8965b3aced6c31bc5e25689f52bfa7cb01da9f10e50fb76c47de1934b93cb12b6db705bb661

data/.rubocop.yml

@@ -6,6 +6,7 @@ AllCops:
   Include:
     - "**/*.rb"
     - "**/*.cap"
+    - "**/*.rake"
     - "**/Gemfile"
     - "**/Rakefile"
     - "appsignal.gemspec"
@@ -13,7 +14,6 @@ AllCops:
     - "pkg/**/*"
     - "tmp/**/*"
     - "vendor/**/*"
-    - "benchmark.rake"
     - "spec/integration/diagnose/**/*"
   DisplayCopNames: true
   UseCache: true

data/CHANGELOG.md

@@ -1,5 +1,202 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.12.0
+
+_Published on 2024-07-22._
+
+### Added
+
+- Add a Rails configuration option to start AppSignal after Rails is initialized. By default, AppSignal will start before the Rails initializers are run. This way it is not possible to configure AppSignal in a Rails initializer using Ruby. To configure AppSignal in a Rails initializer, configure Rails to start AppSignal after it is initialized.
+
+  ```ruby
+  # config/application.rb
+
+  # ...
+
+  module MyApp
+    class Application < Rails::Application
+      # Add this line
+      config.appsignal.start_at = :after_initialize
+
+      # Other config
+    end
+  end
+  ```
+
+  Then, in the initializer:
+
+  ```ruby
+  # config/initializers/appsignal.rb
+
+  Appsignal.config = Appsignal::Config.new(
+    Rails.root,
+    Rails.env,
+    :ignore_actions => ["My action"]
+  )
+  ```
+
+  Be aware that when `start_at` is set to `after_initialize`, AppSignal will not track any errors that occur when the initializers are run and the app fails to start.
+
+  See [our Rails documentation](https://docs.appsignal.com/ruby/integrations/rails.html) for more information.
+
+  (minor [b84a6a36](https://github.com/appsignal/appsignal-ruby/commit/b84a6a3695259b365cde6f69165818a1e1b99197))
+- Add a new method of configuring AppSignal: `Appsignal.configure`. This new method allows apps to configure AppSignal in Ruby.
+
+  ```ruby
+  # The environment will be auto detected
+  Appsignal.configure do |config|
+    config.activejob_report_errors = "discard"
+    config.sidekiq_report_errors = :discard
+    config.ignore_actions = ["My ignored action", "My other ignored action"]
+    config.request_headers << "MY_HTTP_HEADER"
+    config.send_params = true
+    config.enable_host_metrics = false
+  end
+
+  # Explicitly define which environment to start
+  Appsignal.configure(:production) do |config|
+    # Some config
+  end
+  ```
+
+  This new method can be used to update config in Ruby. We still recommend to use the `config/appsignal.yml` file to configure AppSignal whenever possible. Apps that use the `Appsignal.config = Appsignal::Config.new(...)` way of configuring AppSignal, should be updated to use the new `Appsignal.configure` method. The `Appsignal::Config.new` method would overwrite the given "initial config" with the config file's config and config read from environment variables. The `Appsignal.configure` method is leading. The config file, environment variables and `Appsignal.configure` methods can all be mixed.
+
+  See [our configuration guide](https://docs.appsignal.com/ruby/configuration.html) for more information.
+
+  (minor [ba60fff9](https://github.com/appsignal/appsignal-ruby/commit/ba60fff9fa5087c78e171a0608beba882e1a4c92))
+
+### Changed
+
+- Update the Sinatra, Padrino, Grape and Hanami integration setup for applications. Before this change a "appsignal/integrations/sinatra" file would need to be required to load the AppSignal integration for Sinatra. Similar requires exist for other libraries. This has changed to a new integration load mechanism.
+
+  This new load mechanism makes starting AppSignal more predictable when loading multiple integrations, like those for Sinatra, Padrino, Grape and Hanami.
+
+  ```ruby
+  # Sinatra example
+  # Before
+  require "appsignal/integrations/sinatra"
+
+  # After
+  require "appsignal"
+
+  Appsignal.load(:sinatra)
+  Appsignal.start
+  ```
+
+  The `require "appsignal/integrations/sinatra"` will still work, but is deprecated in this release.
+
+  See the documentation for the specific libraries for the latest on how to integrate AppSignal.
+
+  - [Grape](https://docs.appsignal.com/ruby/integrations/grape.html)
+  - [Hanami](https://docs.appsignal.com/ruby/integrations/hanami.html)
+  - [Padrino](https://docs.appsignal.com/ruby/integrations/padrino.html)
+  - [Sinatra](https://docs.appsignal.com/ruby/integrations/sinatra.html)
+
+  When using a combination of the libraries listed above, read our [integration guide](https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html) on how to load and configure AppSignal for multiple integrations at once.
+
+  (minor [35fff8cb](https://github.com/appsignal/appsignal-ruby/commit/35fff8cb135bf024b3bcf95e497af7dcc0a4cc02))
+- Disable the AppSignal Rack EventHandler when AppSignal is not active. It would still trigger our instrumentation when AppSignal is not active. This reduces the instrumentation overhead when AppSignal is not active. (patch [03e7c1b2](https://github.com/appsignal/appsignal-ruby/commit/03e7c1b221caa00af1599ae94e1d4055835c94a7))
+
+### Deprecated
+
+- Deprecate the `Appsignal.config = Appsignal::Config.new(...)` method of configuring AppSignal. See the changelog entry about `Appsignal.configure { ... }` for the new way to configure AppSignal in Ruby. (minor [ba60fff9](https://github.com/appsignal/appsignal-ruby/commit/ba60fff9fa5087c78e171a0608beba882e1a4c92))
+- Deprecate the Hanami integration require: `require "appsignal/integrations/hanami"`. Use the new `Appsignal.load(:hanami)` method instead. Read our [Hanami docs](https://docs.appsignal.com/ruby/integrations/hanami.html) for more information. (patch)
+- Deprecate the Padrino integration require: `require "appsignal/integrations/padrino"`. Use the new `Appsignal.load(:padrino)` method instead. Read our [Padrino docs](https://docs.appsignal.com/ruby/integrations/padrino.html) for more information. (patch)
+- Deprecate the Sinatra integration require: `require "appsignal/integrations/sinatra"`. Use the new `Appsignal.load(:sinatra)` method instead. Read our [Sinatra docs](https://docs.appsignal.com/ruby/integrations/sinatra.html) for more information. (patch)
+- Deprecate the Grape integration require: `require "appsignal/integrations/grape"`. Use the new `Appsignal.load(:grape)` method instead. Read our [Grape docs](https://docs.appsignal.com/ruby/integrations/grape.html) for more information. (patch)
+
+### Fixed
+
+- Fix instrumentation events for response bodies appearing twice. When multiple instrumentation middleware were mounted in an application, it would create duplicate `process_response_body.rack` events. (patch [24b16517](https://github.com/appsignal/appsignal-ruby/commit/24b16517f3bf5e2911345d5d825a1febb3c7aed7))
+
+## 3.11.0
+
+_Published on 2024-07-15._
+
+### Added
+
+- Add `Appsignal.monitor` and `Appsignal.monitor_and_stop` instrumentation helpers. These helpers are a replacement for the `Appsignal.monitor_transaction` and `Appsignal.monitor_single_transaction` helpers.
+
+  Use these new helpers to create an AppSignal transaction and track any exceptions that occur within the instrumented block. This new helper supports custom namespaces and has a simpler way to set an action name. Use this helper in combination with our other `Appsignal.set_*` helpers to add more metadata to the transaction.
+
+  ```ruby
+  # New helper
+  Appsignal.monitor(
+    :namespace => "my_namespace",
+    :action => "MyClass#my_method"
+  ) do
+    # Track an instrumentation event
+    Appsignal.instrument("my_event.my_group") do
+      # Some code
+    end
+  end
+
+  # Old helper
+  Appsignal.monitor_transaction(
+    "process_action.my_group",
+    :class_name => "MyClass",
+    :action_name => "my_method"
+  ) do
+    # Some code
+  end
+  ```
+
+  The `Appsignal.monitor_and_stop` helper can be used in the same scenarios as the `Appsignal.monitor_single_transaction` helper is used. One-off Ruby scripts that are not part of a long running process.
+
+  Read our [instrumentation documentation](https://docs.appsignal.com/ruby/instrumentation/background-jobs.html) for more information about using the`Appsignal.monitor` helper.
+
+  (minor [f38f0cff](https://github.com/appsignal/appsignal-ruby/commit/f38f0cff978c7e7244beae347a8355fff19b13f1))
+- Add `Appsignal.set_session_data` helper. Set custom session data on the current transaction with the `Appsignal.set_session_data` helper. Note that this will overwrite any request session data that would be set automatically on the transaction. When this method is called multiple times, it will overwrite the previously set value.
+
+  ```ruby
+  Appsignal.set_session_data("data1" => "value1", "data2" => "value2")
+  ```
+
+  (patch [48c76635](https://github.com/appsignal/appsignal-ruby/commit/48c76635043a3777de79816bdb2154ad392c1b09))
+- Add `Appsignal.set_headers` helper. Set custom request headers on the current transaction with the `Appsignal.set_headers` helper. Note that this will overwrite any request headers that would be set automatically on the transaction. When this method is called multiple times, it will overwrite the previously set value.
+
+  ```ruby
+  Appsignal.set_headers("PATH_INFO" => "/some-path", "HTTP_USER_AGENT" => "Firefox")
+  ```
+
+  (patch [7d82dffd](https://github.com/appsignal/appsignal-ruby/commit/7d82dffd75a6c7c9a8b6a8fac7e6bbb70104b63c))
+- Report request headers for webmachine apps. (patch [fcfb7a0d](https://github.com/appsignal/appsignal-ruby/commit/fcfb7a0d2545a2144aa61efa61d445c0e11c7749))
+
+### Changed
+
+- Allow tags to have boolean (true/false) values.
+
+  ```ruby
+  Appsignal.set_tags("my_tag_is_amazing" => true)
+  Appsignal.set_tags("my_tag_is_false" => false)
+  ```
+
+  (patch [1b8e86cb](https://github.com/appsignal/appsignal-ruby/commit/1b8e86cba3472ebec78680ca6a2ed8aa76938724))
+- Optimize Sidekiq job arguments being recorded. Job arguments are only fetched and set when we sample the job transaction, which should decrease our overhead for all jobs we don't sample. (patch [3f957301](https://github.com/appsignal/appsignal-ruby/commit/3f95730145d6eef7eb13901853685e4d56d5495c))
+
+### Deprecated
+
+- Deprecate Transaction sample helpers: `Transaction#set_sample_data` and `Transaction#sample_data`. Please use one of the other sample data helpers instead. See our [sample data guide](https://docs.appsignal.com/guides/custom-data/sample-data.html). (patch [2d2e0e43](https://github.com/appsignal/appsignal-ruby/commit/2d2e0e43c9125b4566e3265b6e6ae85e4910652b))
+- Deprecate the `Appsignal::Transaction#set_http_or_background_queue_start` method. Use the `Appsignal::Transaction#set_queue_start` helper instead. (patch [d93e0370](https://github.com/appsignal/appsignal-ruby/commit/d93e0370ff4e37cf8d12652a6e5cca66651a5790))
+- Deprecate the `Appsignal.without_instrumentation` helper. Use the `Appsignal.ignore_instrumentation_events` helper instead. (patch [7cc3c0e4](https://github.com/appsignal/appsignal-ruby/commit/7cc3c0e41615394deec348d5e0a40b7a6c1fc1d9))
+- Deprecate the `Appsignal::Transaction::GenericRequest` class. Use the `Appsignal.set_*` helpers to set metadata on the Transaction instead. Read our [sample data guide](https://docs.appsignal.com/guides/custom-data/sample-data.html) for more information. (patch [1c69d3fd](https://github.com/appsignal/appsignal-ruby/commit/1c69d3fdf47959c240c4732f7e8551802a9eba63))
+- Deprecate the 'ID', 'request', and 'options' arguments for the `Transaction.create` and `Transaction.new` methods. To add metadata to the transaction, use the `Appsignal.set_*` helpers. Read our [sample data guide](https://docs.appsignal.com/guides/custom-data/sample-data.html) for more information on how to set metadata on transactions.
+
+  ```ruby
+  # Before
+  Appsignal::Transaction.create(
+    SecureRandom.uuid,
+    "my_namespace",
+    Appsignal::Transaction::GenericRequest.new(env) # env is a request env Hash
+  )
+
+  # After
+  Appsignal::Transaction.create("my_namespace")
+  ```
+
+  (patch [2fc2c617](https://github.com/appsignal/appsignal-ruby/commit/2fc2c617321bc6a520205cae0cfa42fb3c8fc5d8))
+- Deprecate the `Appsignal.monitor_transaction` and `Appsignal.monitor_single_transaction` helpers. See the entry about the replacement helpers `Appsignal.monitor` and `Appsignal.monitor_and_stop`. (patch [470d5813](https://github.com/appsignal/appsignal-ruby/commit/470d58132270115215093c9cffd16e52829ef4c4))
+
 ## 3.10.0
 
 _Published on 2024-07-08._

data/Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "benchmark-ips"
 # Fix install issue for jruby on gem 3.1.8.
 # No java stub is published.
 gem "bigdecimal", "3.1.7" if RUBY_PLATFORM == "java"

data/Rakefile

@@ -295,7 +295,7 @@ task :console do
   require "irb/completion"
   require "appsignal"
 
-  Appsignal.config = Appsignal::Config.new(".", :console)
+  Appsignal.configure(:console)
 
   ARGV.clear
   IRB.start

data/benchmark.rake

@@ -1,5 +1,12 @@
-require 'appsignal'
-require 'benchmark'
+# frozen_string_literal: true
+
+# Run using: rake --rakefile benchmark.rake [tasks]
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "lib"))
+
+require "benchmark"
+require "benchmark/ips"
+require "appsignal"
 
 def process_rss
   `ps -o rss= -p #{Process.pid}`.to_i
@@ -7,35 +14,110 @@ end
 
 GC.disable
 
-task :default => :'benchmark:all'
+task :default => :"benchmark:all"
 
 namespace :benchmark do
-  task :all => [:run_inactive, :run_active]
+  task :all => [:memory_inactive, :memory_active, :ips]
 
-  task :run_inactive do
-    puts 'Running with appsignal off'
-    ENV['APPSIGNAL_PUSH_API_KEY'] = nil
+  task :memory_inactive do
+    puts "Memory benchmark with AppSignal off"
+    ENV["APPSIGNAL_PUSH_API_KEY"] = nil
     run_benchmark
   end
 
-  task :run_active do
-    puts 'Running with appsignal on'
-    ENV['APPSIGNAL_PUSH_API_KEY'] = 'something'
+  task :memory_active do
+    puts "Memory benchmark with AppSignal on"
+    ENV["APPSIGNAL_PUSH_API_KEY"] = "something"
     run_benchmark
   end
+
+  task :ips do
+    puts "Iterations per second benchmark"
+    start_agent
+    Benchmark.ips do |x|
+      x.config(
+        :time => 5,
+        :warmup => 2
+      )
+
+      x.report("monitor transaction inactive") do |times|
+        ENV["APPSIGNAL_PUSH_API_KEY"] = nil
+
+        monitor_transaction("transaction_#{times}")
+      end
+
+      x.report("monitor transaction active") do |times|
+        ENV["APPSIGNAL_PUSH_API_KEY"] = "something"
+
+        monitor_transaction("transaction_#{times}")
+      end
+
+      x.compare!
+    end
+  end
+end
+
+def start_agent
+  Appsignal.config = Appsignal::Config.new(
+    Dir.pwd,
+    "production",
+    :endpoint => "http://localhost:8080"
+  )
+  Appsignal.start
+end
+
+def monitor_transaction(transaction_id)
+  transaction = Appsignal::Transaction.create(
+    transaction_id,
+    Appsignal::Transaction::HTTP_REQUEST
+  )
+  transaction.set_action("HomeController#show")
+  transaction.set_params(:id => 1)
+
+  Appsignal.instrument("process_action.action_controller") do
+    Appsignal.instrument_sql(
+      "sql.active_record",
+      nil,
+      "SELECT `users`.* FROM `users` WHERE `users`.`id` = ?"
+    )
+    10.times do
+      Appsignal.instrument_sql(
+        "sql.active_record",
+        nil,
+        "SELECT `todos`.* FROM `todos` WHERE `todos`.`id` = ?"
+      )
+    end
+
+    Appsignal.instrument(
+      "render_template.action_view",
+      "app/views/home/show.html.erb"
+    ) do
+      5.times do
+        Appsignal.instrument(
+          "render_partial.action_view",
+          "app/views/home/_piece.html.erb"
+        ) do
+          3.times do
+            Appsignal.instrument("cache.read")
+          end
+        end
+      end
+    end
+  end
+
+  Appsignal::Transaction.complete_current!
 end
 
 def run_benchmark
-  no_transactions = (ENV['NO_TRANSACTIONS'] || 100_000).to_i
-  no_threads = (ENV['NO_THREADS'] || 1).to_i
+  no_transactions = (ENV["NO_TRANSACTIONS"] || 100_000).to_i
+  no_threads = (ENV["NO_THREADS"] || 1).to_i
 
   total_objects = ObjectSpace.count_objects[:TOTAL]
   puts "Initializing, currently #{total_objects} objects"
   puts "RSS: #{process_rss}"
 
-  Appsignal.config = Appsignal::Config.new(Dir.pwd, 'production', :endpoint => 'http://localhost:8080')
-  Appsignal.start
-  puts "Appsignal #{Appsignal.active? ? 'active' : 'not active'}"
+  start_agent
+  puts "Appsignal #{Appsignal.active? ? "active" : "not active"}"
 
   threads = []
   puts "Running #{no_transactions} normal transactions in #{no_threads} threads"
@@ -43,39 +125,14 @@ def run_benchmark
     no_threads.times do
       thread = Thread.new do
         no_transactions.times do |i|
-          request = Appsignal::Transaction::GenericRequest.new(
-            :controller => 'HomeController',
-            :action     => 'show',
-            :params     => {:id => 1}
-          )
-          Appsignal::Transaction.create("transaction_#{i}", Appsignal::Transaction::HTTP_REQUEST, request)
-
-          Appsignal.instrument('process_action.action_controller') do
-            Appsignal.instrument_sql('sql.active_record', nil, 'SELECT `users`.* FROM `users` WHERE `users`.`id` = ?')
-            10.times do
-              Appsignal.instrument_sql('sql.active_record', nil, 'SELECT `todos`.* FROM `todos` WHERE `todos`.`id` = ?')
-            end
-
-            Appsignal.instrument('render_template.action_view', 'app/views/home/show.html.erb') do
-              5.times do
-                Appsignal.instrument('render_partial.action_view', 'app/views/home/_piece.html.erb') do
-                  3.times do
-                    Appsignal.instrument('cache.read')
-                  end
-                end
-              end
-            end
-          end
-
-          Appsignal::Transaction.complete_current!
+          monitor_transaction("transaction_#{i}")
         end
       end
       thread.abort_on_exception = true
       threads << thread
     end
-
     threads.each(&:join)
-    puts 'Finished'
+    puts "Finished"
   end)
 
   puts "Done, currently #{ObjectSpace.count_objects[:TOTAL] - total_objects} objects created"

data/lib/appsignal/cli/demo.rb

@@ -39,7 +39,6 @@ module Appsignal
     #   AppSignal demo documentation
     # @see https://docs.appsignal.com/support/debugging.html
     #   Debugging AppSignal guide
-    # @api private
     class Demo
       class << self
         # @param options [Hash]

data/lib/appsignal/cli/diagnose.rb

@@ -194,7 +194,7 @@ module Appsignal
             initial_config[:log_path] = current_path.join("log")
           end
 
-          Appsignal.config = Appsignal::Config.new(
+          Appsignal._config = Appsignal::Config.new(
             current_path,
             options.fetch(:environment, ENV.fetch("RACK_ENV", ENV.fetch("RAILS_ENV", nil))),
             initial_config