appsignal 3.9.1-java → 3.9.3-java

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.1"
+  VERSION = "3.9.3"
 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,11 @@ require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
 require "appsignal/garbage_collection"
-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/integrations/railtie" if defined?(::Rails)
+require "appsignal/transaction"
+require "appsignal/version"
 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

@@ -385,6 +385,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 +394,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