appsignal 3.9.3-java → 3.10.0-java

data/lib/appsignal/transaction.rb

@@ -74,7 +74,7 @@ module Appsignal
     end
 
     attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options,
-      :discarded, :breadcrumbs
+      :discarded, :breadcrumbs, :custom_data
 
     def initialize(transaction_id, namespace, request, options = {})
       @transaction_id = transaction_id
@@ -84,10 +84,12 @@ module Appsignal
       @paused = false
       @discarded = false
       @tags = {}
+      @custom_data = nil
       @breadcrumbs = []
       @store = Hash.new({})
       @options = options
       @options[:params_method] ||= :params
+      @params = nil
 
       @ext = Appsignal::Extension.start_transaction(
         @transaction_id,
@@ -139,9 +141,13 @@ module Appsignal
     end
 
     def params
-      return @params if defined?(@params)
+      parameters = @params || request_params
 
-      request_params
+      if parameters.respond_to? :call
+        parameters.call
+      else
+        parameters
+      end
     end
 
     # Set parameters on the transaction.
@@ -152,9 +158,17 @@ module Appsignal
     # The parameters set using {#set_params} are leading over those extracted
     # from a request's environment.
     #
+    # When both the `given_params` and a block is given to this method, the
+    # `given_params` argument is leading and the block will _not_ be called.
+    #
+    # @since 3.9.1
     # @param given_params [Hash] The parameters to set on the transaction.
+    # @yield This block is called when the transaction is sampled. The block's
+    #   return value will become the new parameters.
     # @return [void]
-    def set_params(given_params)
+    # @see {Helpers::Instrumentation#set_params}
+    def set_params(given_params = nil, &block)
+      @params = block if block
       @params = given_params if given_params
     end
 
@@ -172,14 +186,20 @@ module Appsignal
     # When no parameters are set this way, the transaction will look for
     # parameters on the {#request} environment.
     #
+    # @since 3.9.1
     # @param given_params [Hash] The parameters to set on the transaction if none are already set.
+    # @yield This block is called when the transaction is sampled. The block's
+    #   return value will become the new parameters.
     # @return [void]
-    def set_params_if_nil(given_params)
-      set_params(given_params) unless @params
+    # @see {Helpers::Instrumentation#set_params_if_nil}
+    def set_params_if_nil(given_params = nil, &block)
+      set_params(given_params, &block) unless @params
     end
 
     # Set tags on the transaction.
     #
+    # When this method is called multiple times, it will merge the tags.
+    #
     # @param given_tags [Hash] Collection of tags.
     # @option given_tags [String, Symbol, Integer] :any
     #   The name of the tag as a Symbol.
@@ -187,13 +207,34 @@ module Appsignal
     #   The name of the tag as a String.
     # @return [void]
     #
-    # @see Appsignal.tag_request
+    # @see Helpers::Instrumentation#tag_request
     # @see https://docs.appsignal.com/ruby/instrumentation/tagging.html
     #   Tagging guide
     def set_tags(given_tags = {})
       @tags.merge!(given_tags)
     end
 
+    # Set custom data on the transaction.
+    #
+    # When this method is called multiple times, it will overwrite the
+    # previously set value.
+    #
+    # @since 3.10.0
+    # @see Appsignal.set_custom_data
+    # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+    #   Sample data guide
+    # @param data [Hash/Array]
+    # @return [void]
+    def set_custom_data(data)
+      case data
+      when Array, Hash
+        @custom_data = data
+      else
+        Appsignal.internal_logger
+          .error("set_custom_data: Unsupported data type #{data.class} received.")
+      end
+    end
+
     # Add breadcrumbs to the transaction.
     #
     # @param category [String] category of breadcrumb
@@ -376,7 +417,8 @@ module Appsignal
         :session_data => sanitized_session_data,
         :metadata => sanitized_metadata,
         :tags => sanitized_tags,
-        :breadcrumbs => breadcrumbs
+        :breadcrumbs => breadcrumbs,
+        :custom_data => custom_data
       }.each do |key, data|
         set_sample_data(key, data)
       end

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -324,8 +324,10 @@ require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
 require "appsignal/garbage_collection"
+require "appsignal/rack"
+require "appsignal/rack/body_wrapper"
 require "appsignal/rack/abstract_middleware"
-require "appsignal/rack/generic_instrumentation"
+require "appsignal/rack/instrumentation_middleware"
 require "appsignal/rack/event_handler"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"

data/spec/lib/appsignal/config_spec.rb

@@ -165,6 +165,7 @@ describe Appsignal::Config do
         :enable_statsd                  => true,
         :enable_nginx_metrics           => false,
         :enable_rails_error_reporter    => true,
+        :enable_rake_performance_instrumentation => false,
         :endpoint                       => "https://push.appsignal.com",
         :files_world_accessible         => true,
         :filter_metadata                => [],

data/spec/lib/appsignal/hooks/rake_spec.rb

@@ -1,41 +1,89 @@
 require "rake"
 
 describe Appsignal::Hooks::RakeHook do
+  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
   let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
   let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
-  let(:generic_request) { Appsignal::Transaction::GenericRequest.new({}) }
-  before(:context) { start_agent }
+  before do
+    start_agent
+    allow(Kernel).to receive(:at_exit)
+  end
+  around { |example| keep_transactions { example.run } }
+  after do
+    if helper.instance_variable_defined?(:@register_at_exit_hook)
+      helper.remove_instance_variable(:@register_at_exit_hook)
+    end
+  end
+
+  def expect_to_not_have_registered_at_exit_hook
+    expect(Kernel).to_not have_received(:at_exit)
+  end
+
+  def expect_to_have_registered_at_exit_hook
+    expect(Kernel).to have_received(:at_exit)
+  end
 
   describe "#execute" do
     context "without error" do
-      before { expect(Appsignal).to_not receive(:stop) }
-
       def perform
         task.execute(arguments)
       end
 
-      it "creates no transaction" do
-        expect { perform }.to_not(change { created_transactions.count })
+      context "with :enable_rake_performance_instrumentation == false" do
+        before do
+          Appsignal.config[:enable_rake_performance_instrumentation] = false
+        end
+
+        it "creates no transaction" do
+          expect { perform }.to_not(change { created_transactions.count })
+        end
+
+        it "calls the original task" do
+          expect(perform).to eq([])
+        end
+
+        it "does not register an at_exit hook" do
+          perform
+          expect_to_not_have_registered_at_exit_hook
+        end
       end
 
-      it "calls the original task" do
-        expect(perform).to eq([])
+      context "with :enable_rake_performance_instrumentation == true" do
+        before do
+          Appsignal.config[:enable_rake_performance_instrumentation] = true
+        end
+
+        it "creates a transaction" do
+          expect { perform }.to(change { created_transactions.count }.by(1))
+
+          transaction = last_transaction
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+          expect(transaction).to have_action("task:name")
+          expect(transaction).to_not have_error
+          expect(transaction).to include_params("foo" => "bar")
+          expect(transaction).to include_event("name" => "task.rake")
+          expect(transaction).to be_completed
+        end
+
+        it "calls the original task" do
+          expect(perform).to eq([])
+        end
+
+        it "registers an at_exit hook" do
+          perform
+          expect_to_have_registered_at_exit_hook
+        end
       end
     end
 
     context "with error" do
-      let(:error) { ExampleException }
       before do
-        task.enhance { raise error, "my error message" }
-        # We don't call `and_call_original` here as we don't want AppSignal to
-        # stop and start for every spec.
-        expect(Appsignal).to receive(:stop).with("rake")
+        task.enhance { raise ExampleException, "error message" }
       end
 
       def perform
-        keep_transactions do
-          expect { task.execute(arguments) }.to raise_error(error)
-        end
+        expect { task.execute(arguments) }.to raise_error(ExampleException, "error message")
       end
 
       it "creates a background job transaction" do
@@ -45,11 +93,16 @@ describe Appsignal::Hooks::RakeHook do
         expect(transaction).to have_id
         expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
         expect(transaction).to have_action("task:name")
-        expect(transaction).to have_error("ExampleException", "my error message")
+        expect(transaction).to have_error("ExampleException", "error message")
         expect(transaction).to include_params("foo" => "bar")
         expect(transaction).to be_completed
       end
 
+      it "registers an at_exit hook" do
+        perform
+        expect_to_have_registered_at_exit_hook
+      end
+
       context "when first argument is not a `Rake::TaskArguments`" do
         let(:arguments) { nil }
 
@@ -62,3 +115,33 @@ describe Appsignal::Hooks::RakeHook do
     end
   end
 end
+
+describe "Appsignal::Integrations::RakeIntegrationHelper" do
+  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
+  describe ".register_at_exit_hook" do
+    before do
+      start_agent
+      allow(Appsignal).to receive(:stop)
+    end
+
+    it "registers the at_exit hook only once" do
+      allow(Kernel).to receive(:at_exit)
+      helper.register_at_exit_hook
+      helper.register_at_exit_hook
+      expect(Kernel).to have_received(:at_exit).once
+    end
+  end
+
+  describe ".at_exit_hook" do
+    let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
+    before do
+      start_agent
+      allow(Appsignal).to receive(:stop)
+    end
+
+    it "calls Appsignal.stop" do
+      helper.at_exit_hook
+      expect(Appsignal).to have_received(:stop).with("rake")
+    end
+  end
+end