appsignal 3.9.2-java → 3.10.0-java

data/lib/appsignal/rack/streaming_listener.rb

@@ -1,73 +1,27 @@
 # frozen_string_literal: true
 
+Appsignal::Utils::StdoutAndLoggerMessage.warning \
+  "The constant Appsignal::Rack::StreamingListener has been deprecated. " \
+    "Please update the constant name to " \
+    "Appsignal::Rack::InstrumentationMiddleware."
+
 module Appsignal
   module Rack
-    # Appsignal module that tracks exceptions in Streaming rack responses.
+    # Instrumentation middleware that tracks exceptions in streaming Rack
+    # responses.
     #
     # @api private
-    class StreamingListener
+    class StreamingListener < AbstractMiddleware
       def initialize(app, options = {})
-        Appsignal.internal_logger.debug "Initializing Appsignal::Rack::StreamingListener"
-        @app = app
-        @options = options
-      end
-
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
+        options[:instrument_event_name] ||= "process_streaming_request.rack"
+        super
       end
 
-      def call_with_appsignal_monitoring(env)
-        request = ::Rack::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request
-        )
+      def add_transaction_metadata_after(transaction, request)
+        transaction.set_action_if_nil(request.env["appsignal.action"])
 
-        # Instrument a `process_action`, to set params/action name
-        status, headers, body =
-          Appsignal.instrument("process_action.rack") do
-            @app.call(env)
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            transaction.set_error(e)
-            raise e
-          ensure
-            transaction.set_action_if_nil(env["appsignal.action"])
-            transaction.set_metadata("path", request.path)
-            transaction.set_metadata("method", request.request_method)
-            transaction.set_http_or_background_queue_start
-          end
-
-        # Wrap the result body with our StreamWrapper
-        [status, headers, StreamWrapper.new(body, transaction)]
+        super
       end
     end
   end
-
-  class StreamWrapper
-    def initialize(stream, transaction)
-      @stream = stream
-      @transaction = transaction
-    end
-
-    def each(&block)
-      @stream.each(&block)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      @transaction.set_error(e)
-      raise e
-    end
-
-    def close
-      @stream.close if @stream.respond_to?(:close)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      @transaction.set_error(e)
-      raise e
-    ensure
-      Appsignal::Transaction.complete_current!
-    end
-  end
 end

data/lib/appsignal/rack.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # @api private
+  module Rack
+    # Alias constants that have moved with a warning message that points to the
+    # place to update the reference.
+    def self.const_missing(name)
+      case name
+      when :GenericInstrumentation
+        require "appsignal/rack/generic_instrumentation"
+
+        callers = caller
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The constant Appsignal::Rack::GenericInstrumentation has been deprecated. " \
+            "Please use the new Appsignal::Rack::InstrumentationMiddleware middleware. " \
+            "This new middleware does not default the action name to 'unknown'. " \
+            "Set the action name for the endpoint using the Appsignal.set_action helper. " \
+            "Read our Rack docs for more information " \
+            "https://docs.appsignal.com/ruby/integrations/rack.html " \
+            "Update the constant name to " \
+            "Appsignal::Rack::InstrumentationMiddleware in the following file to " \
+            "remove this message.\n#{callers.first}"
+        # Return the alias so it can't ever get stuck in a recursive loop
+        Appsignal::Rack::GenericInstrumentationAlias
+      else
+        super
+      end
+    end
+  end
+end

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/utils/integration_memory_logger.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Appsignal
+  module Utils
+    # @api private
+    class IntegrationMemoryLogger
+      LEVELS = {
+        Logger::DEBUG => :DEBUG,
+        Logger::INFO => :INFO,
+        Logger::WARN => :WARN,
+        Logger::ERROR => :ERROR,
+        Logger::FATAL => :FATAL,
+        Logger::UNKNOWN => :UNKNOWN
+      }.freeze
+
+      attr_accessor :formatter, :level
+
+      def add(severity, message, _progname = nil)
+        message = formatter.call(severity, Time.now, nil, message) if formatter
+        messages[severity] << message
+      end
+      alias log add
+
+      def debug(message)
+        add(:DEBUG, message)
+      end
+
+      def info(message)
+        add(:INFO, message)
+      end
+
+      def warn(message)
+        add(:WARN, message)
+      end
+
+      def seen_keys
+        @seen_keys ||= Set.new
+      end
+
+      def warn_once_then_debug(key, message)
+        if seen_keys.add?(key).nil?
+          debug message
+        else
+          warn message
+        end
+      end
+
+      def error(message)
+        add(:ERROR, message)
+      end
+
+      def fatal(message)
+        add(:FATAL, message)
+      end
+
+      def unknown(message)
+        add(:UNKNOWN, message)
+      end
+
+      def clear
+        messages.clear
+      end
+
+      def messages
+        @messages ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def messages_for_level(level)
+        levels = LEVELS.select { |log_level| log_level >= level }.values
+        messages
+          .select { |log_level| levels.include?(log_level) }
+          .flat_map { |_level, message| message }
+      end
+    end
+  end
+end

data/lib/appsignal/utils.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "appsignal/utils/integration_memory_logger"
 require "appsignal/utils/stdout_and_logger_message"
 require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -55,14 +55,15 @@ module Appsignal
     #   directly.
     #
     #   If no logger has been set, it will return a "in memory logger", using
-    #   `in_memory_log`. Once AppSignal is started (using {.start}) the
-    #   contents of the "in memory logger" is written to the new logger.
+    #   {Utils::IntegrationMemoryLogger}. Once AppSignal is started (using
+    #   {.start}) the contents of the "in memory logger" is written to the new
+    #   logger.
     #
     #   @note some classes may have options to set custom loggers. Their
     #     defaults are pointed to this attribute.
     #   @api private
     #   @return [Logger]
-    #   @see start_logger
+    #   @see start
     attr_writer :internal_logger
 
     # @api private
@@ -84,8 +85,6 @@ module Appsignal
     # AppSignal](https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html)
     # guide.
     #
-    # To start the logger see {.start_logger}.
-    #
     # @example
     #   Appsignal.start
     #
@@ -108,8 +107,9 @@ module Appsignal
         ENV["APPSIGNAL_APP_ENV"] || ENV["RAILS_ENV"] || ENV.fetch("RACK_ENV", nil)
       )
 
+      _start_logger
+
       if config.valid?
-        internal_logger.level = config.log_level
         if config.active?
           internal_logger.info "Starting AppSignal #{Appsignal::VERSION} " \
             "(#{$PROGRAM_NAME}, Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM})"
@@ -160,7 +160,7 @@ module Appsignal
     def forked
       return unless active?
 
-      Appsignal.start_logger
+      Appsignal._start_logger
       internal_logger.debug("Forked process, resubscribing and restarting extension")
       Appsignal::Extension.start
     end
@@ -169,27 +169,15 @@ module Appsignal
       Appsignal::Extension.get_server_state(key)
     end
 
-    # In memory internal logger used before any internal logger is started with
-    # {.start_logger}.
-    #
-    # The contents of this logger are flushed to the logger in {.start_logger}.
-    #
-    # @api private
-    # @return [StringIO]
-    def in_memory_log
-      if defined?(@in_memory_log) && @in_memory_log
-        @in_memory_log
-      else
-        @in_memory_log = StringIO.new
-      end
+    def in_memory_logger
+      @in_memory_logger ||=
+        Appsignal::Utils::IntegrationMemoryLogger.new.tap do |l|
+          l.formatter = log_formatter("appsignal")
+        end
     end
 
     def internal_logger
-      @internal_logger ||=
-        Appsignal::Utils::IntegrationLogger.new(in_memory_log).tap do |l|
-          l.level = ::Logger::INFO
-          l.formatter = log_formatter("appsignal")
-        end
+      @internal_logger ||= in_memory_logger
     end
 
     # @api private
@@ -201,14 +189,26 @@ module Appsignal
       end
     end
 
+    # @deprecated Only {.start} has to be called.
+    # @return [void]
+    # @since 0.7.0
+    def start_logger
+      callers = caller
+      Appsignal::Utils::StdoutAndLoggerMessage.warning \
+        "Callng 'Appsignal.start_logger' is deprecated. " \
+          "The logger will be started when calling 'Appsignal.start'. " \
+          "Remove the 'Appsignal.start_logger' call in the following file to " \
+          "remove this message.\n#{callers.first}"
+    end
+
     # Start the AppSignal internal logger.
     #
     # Sets the log level and sets the logger. Uses a file-based logger or the
     # STDOUT-based logger. See the `:log` configuration option.
     #
+    # @api private
     # @return [void]
-    # @since 0.7.0
-    def start_logger
+    def _start_logger
       if config && config[:log] == "file" && config.log_file_path
         start_internal_file_logger(config.log_file_path)
       else
@@ -221,10 +221,11 @@ module Appsignal
         else
           Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-      return unless @in_memory_log
+      return unless @in_memory_logger
 
-      internal_logger << @in_memory_log.string
-      @in_memory_log = nil
+      messages = @in_memory_logger.messages_for_level(internal_logger.level)
+      internal_logger << messages.join
+      @in_memory_logger = nil
     end
 
     # Returns if the C-extension was loaded properly.
@@ -323,11 +324,13 @@ 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/instrumentation_middleware"
+require "appsignal/rack/event_handler"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
-require "appsignal/rack/abstract_middleware"
-require "appsignal/rack/generic_instrumentation"
-require "appsignal/rack/event_handler"
 require "appsignal/transmitter"
 require "appsignal/heartbeat"

data/spec/.rubocop.yml

@@ -3,5 +3,5 @@ inherit_from: ../.rubocop.yml
 Metrics/BlockLength:
   Enabled: false
 
-# Metrics/LineLength:
+# Layout/LineLength:
 #   Max: 100

data/spec/lib/appsignal/cli/diagnose_spec.rb

@@ -1320,7 +1320,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           end
 
           it "transmits path data in report" do
-            mode = ENV["RUNNING_IN_CI"] ? "40775" : "40755"
+            mode = "40755"
             expect(received_report["paths"]["root_path"]).to eq(
               "path" => root_path,
               "exists" => true,

data/spec/lib/appsignal/cli/install_spec.rb

@@ -155,7 +155,7 @@ describe Appsignal::CLI::Install do
     end
 
     it "requires an application name" do
-      expect(output.scan(/Enter application name:/).length).to eq(2)
+      expect(output.scan("Enter application name:").length).to eq(2)
     end
   end
 
@@ -184,7 +184,7 @@ describe Appsignal::CLI::Install do
           run
 
           expect(output).to_not include "Adding AppSignal integration to Capfile"
-          expect(File.read(capfile).scan(/appsignal/).count).to eq(1)
+          expect(File.read(capfile).scan("appsignal").count).to eq(1)
         end
       end
 
@@ -351,7 +351,7 @@ describe Appsignal::CLI::Install do
           choose_environment_config
           run
 
-          expect(output.scan(/Choose app's display name:/).length).to eq(2)
+          expect(output.scan("Choose app's display name:").length).to eq(2)
         end
 
         context "with configuration using environment variables" do

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                => [],
@@ -385,6 +386,8 @@ describe Appsignal::Config do
 
     context "without the selected env" do
       let(:config) { project_fixture_config("nonsense") }
+      let(:log_stream) { std_stream }
+      let(:log) { log_contents(log_stream) }
 
       it "is not valid or active" do
         expect(config.valid?).to be_falsy
@@ -392,11 +395,11 @@ describe Appsignal::Config do
       end
 
       it "logs an error" do
-        expect_any_instance_of(Logger).to receive(:error).once
-          .with("Not loading from config file: config for 'nonsense' not found")
-        expect_any_instance_of(Logger).to receive(:error).once
-          .with("Push API key not set after loading config")
-        config
+        use_logger_with(log_stream) { config }
+        expect(log)
+          .to contains_log(:error, "Not loading from config file: config for 'nonsense' not found")
+        expect(log)
+          .to contains_log(:error, "Push API key not set after loading config")
       end
     end
   end

data/spec/lib/appsignal/demo_spec.rb

@@ -32,56 +32,53 @@ describe Appsignal::Demo do
   end
 
   describe ".create_example_error_request" do
-    let!(:error_transaction) { http_request_transaction }
-    let(:config) { project_fixture_config("production") }
-    before do
-      Appsignal.config = config
-      expect(Appsignal::Transaction).to receive(:new).with(
-        kind_of(String),
-        Appsignal::Transaction::HTTP_REQUEST,
-        kind_of(::Rack::Request),
-        kind_of(Hash)
-      ).and_return(error_transaction)
-    end
-    subject { described_class.send(:create_example_error_request) }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     it "sets an error" do
-      expect(error_transaction).to receive(:set_error).with(kind_of(described_class::TestError))
-      expect(error_transaction).to receive(:set_metadata).with("path", "/hello")
-      expect(error_transaction).to receive(:set_metadata).with("method", "GET")
-      expect(error_transaction).to receive(:set_metadata).with("demo_sample", "true")
-      expect(error_transaction).to receive(:complete)
-      subject
+      described_class.send(:create_example_error_request)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction).to have_action("DemoController#hello")
+      expect(transaction).to have_error(
+        "Appsignal::Demo::TestError",
+        "Hello world! This is an error used for demonstration purposes."
+      )
+      expect(transaction).to include_metadata(
+        "path" => "/hello",
+        "method" => "GET",
+        "demo_sample" => "true"
+      )
+      expect(transaction).to be_completed
     end
   end
 
   describe ".create_example_performance_request" do
-    let!(:performance_transaction) { http_request_transaction }
-    let(:config) { project_fixture_config("production") }
-    before do
-      Appsignal.config = config
-      expect(Appsignal::Transaction).to receive(:new).with(
-        kind_of(String),
-        Appsignal::Transaction::HTTP_REQUEST,
-        kind_of(::Rack::Request),
-        kind_of(Hash)
-      ).and_return(performance_transaction)
-    end
-    subject { described_class.send(:create_example_performance_request) }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     it "sends a performance sample" do
-      expect(performance_transaction).to receive(:start_event)
-      expect(performance_transaction).to receive(:finish_event).with(
-        "action_view.render",
-        "Render hello.html.erb",
-        "<h1>Hello world!</h1>",
-        Appsignal::EventFormatter::DEFAULT
+      described_class.send(:create_example_performance_request)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction).to have_action("DemoController#hello")
+      expect(transaction).to_not have_error
+      expect(transaction).to include_metadata(
+        "path" => "/hello",
+        "method" => "GET",
+        "demo_sample" => "true"
+      )
+      expect(transaction).to include_event(
+        "name" => "action_view.render",
+        "title" => "Render hello.html.erb",
+        "body" => "<h1>Hello world!</h1>",
+        "body_format" => Appsignal::EventFormatter::DEFAULT
       )
-      expect(performance_transaction).to receive(:set_metadata).with("path", "/hello")
-      expect(performance_transaction).to receive(:set_metadata).with("method", "GET")
-      expect(performance_transaction).to receive(:set_metadata).with("demo_sample", "true")
-      expect(performance_transaction).to receive(:complete)
-      subject
+      expect(transaction).to be_completed
     end
   end
 end