appsignal 2.8.4-java → 2.9.0-java

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -32,7 +32,7 @@ module Appsignal
       attr_reader :raise_errors_on
 
       def initialize(app, options = {})
-        Appsignal.logger.debug "Initializing Appsignal::Rack::SinatraInstrumentation"
+        Appsignal.logger.debug "Initializing Appsignal::Rack::SinatraBaseInstrumentation"
         @app = app
         @options = options
         @raise_errors_on = raise_errors?(@app)

data/lib/appsignal/system.rb

@@ -16,21 +16,6 @@ module Appsignal
       ENV.key? "DYNO".freeze
     end
 
-    # Returns the architecture for which the agent was installed.
-    #
-    # This value is saved when the gem is installed in `ext/extconf.rb`.
-    # We use this value to build the diagnose report with the installed
-    # CPU type and platform, rather than the detected architecture in
-    # {.agent_platform} during the diagnose run.
-    #
-    # @api private
-    # @return [String]
-    def self.installed_agent_architecture
-      architecture_file = File.join(GEM_EXT_PATH, "appsignal.architecture")
-      return unless File.exist?(architecture_file)
-      File.read(architecture_file)
-    end
-
     # Detect agent and extension platform build
     #
     # Used by `ext/extconf.rb` to select which build it should download and
@@ -42,7 +27,7 @@ module Appsignal
     # @api private
     # @return [String]
     def self.agent_platform
-      return MUSL_TARGET if ENV["APPSIGNAL_BUILD_FOR_MUSL"]
+      return MUSL_TARGET if force_musl_build?
 
       host_os = RbConfig::CONFIG["host_os"].downcase
       local_os =
@@ -59,8 +44,8 @@ module Appsignal
       if local_os =~ /linux/
         ldd_output = ldd_version_output
         return MUSL_TARGET if ldd_output.include? "musl"
-        ldd_version = ldd_output.match(/\d+\.\d+/)
-        if ldd_version && versionify(ldd_version[0]) < versionify("2.15")
+        ldd_version = extract_ldd_version(ldd_output)
+        if ldd_version && versionify(ldd_version) < versionify("2.15")
           return MUSL_TARGET
         end
       end
@@ -68,6 +53,13 @@ module Appsignal
       local_os
     end
 
+    # Returns whether or not the musl build was forced by the user.
+    #
+    # @api private
+    def self.force_musl_build?
+      %w[true 1].include?(ENV["APPSIGNAL_BUILD_FOR_MUSL"])
+    end
+
     # @api private
     def self.versionify(version)
       Gem::Version.new(version)
@@ -78,6 +70,12 @@ module Appsignal
       `ldd --version 2>&1`
     end
 
+    # @api private
+    def self.extract_ldd_version(string)
+      ldd_version = string.match(/\d+\.\d+/)
+      ldd_version && ldd_version[0]
+    end
+
     def self.jruby?
       RUBY_PLATFORM == "java"
     end

data/lib/appsignal/utils/rails_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Utils
+    module RailsHelper
+      def self.detected_rails_app_name
+        rails_class = Rails.application.class
+        if rails_class.respond_to? :module_parent_name # Rails 6
+          rails_class.module_parent_name
+        else # Older Rails versions
+          rails_class.parent_name
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.8.4".freeze
+  VERSION = "2.9.0".freeze
 end

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

@@ -190,8 +190,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       it "outputs version numbers" do
         expect(output).to include \
           "Gem version: #{Appsignal::VERSION}",
-          "Agent version: #{Appsignal::Extension.agent_version}",
-          "Agent architecture: #{Appsignal::System.installed_agent_architecture}"
+          "Agent version: #{Appsignal::Extension.agent_version}"
       end
 
       it "transmits version numbers in report" do
@@ -200,7 +199,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             "language" => "ruby",
             "package_version" => Appsignal::VERSION,
             "agent_version" => Appsignal::Extension.agent_version,
-            "agent_architecture" => Appsignal::System.installed_agent_architecture,
             "extension_loaded" => true
           }
         )
@@ -238,6 +236,131 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       end
     end
 
+    describe "installation report" do
+      let(:rbconfig) { RbConfig::CONFIG }
+
+      it "adds the installation report to the diagnostics report" do
+        run
+        jruby = DependencyHelper.running_jruby?
+        expect(received_report["installation"]).to match(
+          "result" => {
+            "status" => "success"
+          },
+          "language" => {
+            "name" => "ruby",
+            "version" => "#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}",
+            "implementation" => jruby ? "jruby" : "ruby"
+          },
+          "download" => {
+            "download_url" => kind_of(String),
+            "checksum" => "verified"
+          },
+          "build" => {
+            "time" => kind_of(String),
+            "package_path" => File.expand_path("../../../../../", __FILE__),
+            "architecture" => rbconfig["host_cpu"],
+            "target" => Appsignal::System.agent_platform,
+            "musl_override" => false,
+            "library_type" => jruby ? "dynamic" : "static",
+            "source" => "remote",
+            "dependencies" => kind_of(Hash),
+            "flags" => kind_of(Hash),
+            "agent_version" => Appsignal::Extension.agent_version
+          },
+          "host" => {
+            "root_user" => false,
+            "dependencies" => kind_of(Hash)
+          }
+        )
+      end
+
+      it "prints the extension installation report" do
+        run
+        jruby = Appsignal::System.jruby?
+        expect(output).to include(
+          "Extension installation report",
+          "Language details",
+          "  Implementation: #{jruby ? "jruby" : "ruby"}",
+          "  Ruby version: #{"#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"}",
+          "Download details",
+          "  Download URL: https://",
+          "  Checksum: verified",
+          "Build details",
+          "  Install time: 20",
+          "  Architecture: #{rbconfig["host_cpu"]}",
+          "  Target: #{Appsignal::System.agent_platform}",
+          "  Musl override: false",
+          "  Library type: #{jruby ? "dynamic" : "static"}",
+          "  Dependencies: {",
+          "  Flags: {",
+          "Host details",
+          "  Root user: false",
+          "  Dependencies: {"
+        )
+      end
+
+      context "without install report" do
+        let(:error) { RuntimeError.new("foo") }
+        before do
+          allow(File).to receive(:read).and_call_original
+          expect(File).to receive(:read)
+            .with(File.expand_path("../../../../../ext/install.report", __FILE__))
+            .and_raise(error)
+        end
+
+        it "sends an error" do
+          run
+          expect(received_report["installation"]).to match(
+            "parsing_error" => {
+              "error" => "RuntimeError: foo",
+              "backtrace" => error.backtrace
+            }
+          )
+        end
+
+        it "prints the error" do
+          run
+          expect(output).to include(
+            "Extension installation report",
+            "  Error found while parsing the report.",
+            "  Error: RuntimeError: foo"
+          )
+          expect(output).to_not include("Raw report:")
+        end
+      end
+
+      context "when report is invalid YAML" do
+        let(:raw_report) { "foo:\nbar" }
+        before do
+          allow(File).to receive(:read).and_call_original
+          expect(File).to receive(:read)
+            .with(File.expand_path("../../../../../ext/install.report", __FILE__))
+            .and_return(raw_report)
+        end
+
+        it "sends an error" do
+          run
+          expect(received_report["installation"]).to match(
+            "parsing_error" => {
+              "error" => kind_of(String),
+              "backtrace" => kind_of(Array),
+              "raw" => raw_report
+            }
+          )
+        end
+
+        it "prints the error" do
+          run
+          expect(output).to include(
+            "Extension installation report",
+            "  Error found while parsing the report.",
+            "  Error: ",
+            "  Raw report:\n#{raw_report}"
+          )
+        end
+      end
+    end
+
     describe "agent diagnostics" do
       let(:working_directory_stat) { File.stat("/tmp/appsignal") }
 
@@ -471,7 +594,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         context "when not root user" do
           it "outputs false" do
             run
-            expect(output).to include "root user: false"
+            expect(output).to include "Root user: false"
           end
 
           it "transmits root: false in report" do
@@ -487,7 +610,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           end
 
           it "outputs true, with warning" do
-            expect(output).to include "root user: true (not recommended)"
+            expect(output).to include "Root user: true (not recommended)"
           end
 
           it "transmits root: true in report" do
@@ -834,7 +957,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           expect(received_report["paths"].keys).to match_array(
             %w[
               package_install_path root_path working_dir log_dir_path
-              ext/install.log ext/mkmf.log appsignal.log
+              ext/mkmf.log appsignal.log
             ]
           )
         end
@@ -1138,22 +1261,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
       end
 
-      describe "install.log" do
-        it_behaves_like "diagnose file" do
-          let(:filename) { File.join("ext", "install.log") }
-          before do
-            expect_any_instance_of(Appsignal::CLI::Diagnose::Paths).to receive(:gem_path)
-              .at_least(:once)
-              .and_return(parent_directory)
-          end
-        end
-
-        it "outputs header" do
-          run
-          expect(output).to include("Extension install log")
-        end
-      end
-
       describe "mkmf.log" do
         it_behaves_like "diagnose file" do
           let(:filename) { File.join("ext", "mkmf.log") }

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

@@ -243,7 +243,12 @@ describe Appsignal::CLI::Install do
 
   if rails_present?
     context "with rails" do
-      let(:installation_instructions) { ["Installing for Ruby on Rails"] }
+      let(:installation_instructions) do
+        [
+          "Installing for Ruby on Rails",
+          "Your app's name is: 'MyApp'"
+        ]
+      end
       let(:app_name) { "MyApp" }
       let(:config_dir) { File.join(tmp_dir, "config") }
       let(:environments_dir) { File.join(config_dir, "environments") }

data/spec/lib/appsignal/config_spec.rb

@@ -130,7 +130,7 @@ describe Appsignal::Config do
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
-        :enable_minutely_probes         => false,
+        :enable_minutely_probes         => true,
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :dns_servers                    => [],
         :files_world_accessible         => true,
@@ -218,7 +218,8 @@ describe Appsignal::Config do
         :active => true,
         :push_api_key => "abc",
         :name => "TestApp",
-        :request_headers => kind_of(Array)
+        :request_headers => kind_of(Array),
+        :enable_minutely_probes => false
       )
     end
 
@@ -492,7 +493,6 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_IGNORE_NAMESPACES"]).to            eq "admin,private_namespace"
       expect(ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]).to         eq "false"
       expect(ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]).to          eq "true"
-      expect(ENV["_APPSIGNAL_ENABLE_MINUTELY_PROBES"]).to       eq "false"
       expect(ENV["_APPSIGNAL_HOSTNAME"]).to                     eq ""
       expect(ENV["_APPSIGNAL_PROCESS_NAME"]).to                 include "rspec"
       expect(ENV["_APPSIGNAL_CA_FILE_PATH"]).to                 eq File.join(resources_dir, "cacert.pem")

data/spec/lib/appsignal/event_formatter/moped/query_formatter_spec.rb

@@ -16,6 +16,12 @@ describe Appsignal::EventFormatter::Moped::QueryFormatter do
       it { is_expected.to be_nil }
     end
 
+    context "when ops is nil in the payload" do
+      let(:payload) { { :ops => nil } }
+
+      it { is_expected.to be_nil }
+    end
+
     context "Moped::Protocol::Command" do
       let(:op) do
         double(

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -10,9 +10,10 @@ class MockFormatter < Appsignal::EventFormatter
   end
 end
 
-class MissingFormatMockFormatter < Appsignal::EventFormatter
-  def transform(_payload)
-  end
+class MockFormatterDouble < MockFormatter
+end
+
+class MissingFormatMockFormatter
 end
 
 class IncorrectFormatMockFormatter < Appsignal::EventFormatter
@@ -20,109 +21,207 @@ class IncorrectFormatMockFormatter < Appsignal::EventFormatter
   end
 end
 
+class IncorrectFormatMock2Formatter < Appsignal::EventFormatter
+  def format(_payload, _foo = nil)
+  end
+end
+
 class MockDependentFormatter < Appsignal::EventFormatter
   def initialize
     NonsenseDependency.something
   end
-end
 
-Appsignal::EventFormatter.register "mock", MockFormatter
-Appsignal::EventFormatter.register "mock.dependent", MockDependentFormatter
+  def format(_payload)
+  end
+end
 
 describe Appsignal::EventFormatter do
-  before do
-    klass.register("mock", MockFormatter)
+  let(:klass) { described_class }
+  around do |example|
+    original_formatters = described_class.formatters
+    example.run
+    described_class.class_variable_set(:@@formatters, original_formatters)
   end
 
-  let(:klass) { Appsignal::EventFormatter }
-
-  let(:deprecated_formatter) do
-    Class.new(Appsignal::EventFormatter) do
-      register "mock.deprecated"
-
-      def format(_payload)
-      end
-    end
-  end
+  describe ".register" do
+    it "registers a formatter" do
+      expect(klass.registered?("mock")).to be_falsy
 
-  context "registering and unregistering formatters" do
-    let(:out_stream) { std_stream }
-    let(:output) { out_stream.read }
+      klass.register "mock", MockFormatter
 
-    it "registers a formatter" do
       expect(klass.formatters["mock"]).to be_instance_of(MockFormatter)
+      expect(klass.formatter_classes["mock"]).to eq MockFormatter
     end
 
-    it "knows whether a formatter is registered" do
-      expect(klass.registered?("mock")).to be_truthy
-      expect(klass.registered?("mock", MockFormatter)).to be_truthy
-      expect(klass.registered?("mock", Hash)).to be_falsy
-      expect(klass.registered?("nonsense")).to be_falsy
+    context "when a formatter with the name already exists" do
+      it "does not register the formatter again" do
+        logs = capture_logs do
+          klass.register("mock.twice", MockFormatter)
+          klass.register("mock.twice", MockFormatter)
+        end
+        expect(klass.registered?("mock.twice")).to be_truthy
+        expect(logs).to contains_log :warn, \
+          "Formatter for 'mock.twice' already registered, not registering 'MockFormatter'"
+      end
     end
 
-    it "doesn't register formatters that raise a name error in the initializer" do
-      expect(klass.registered?("mock.dependent")).to be_falsy
+    context "when there is an error initializing the formatter" do
+      it "does not register the formatter and logs an error" do
+        logs = capture_logs do
+          described_class.register "mock.dependent", MockDependentFormatter
+        end
+        expect(klass.registered?("mock.dependent")).to be_falsy
+        expect(logs).to contains_log :error, \
+          "'uninitialized constant MockDependentFormatter::NonsenseDependency' " \
+          "when initializing mock.dependent event formatter"
+      end
     end
 
-    it "registers a custom formatter" do
-      klass.register("mock.specific", MockFormatter)
+    context "when formatter has no format/1 method" do
+      context "when the formatter has no format method" do
+        it "does not register the formatter and logs an error" do
+          logs = capture_logs do
+            described_class.register "mock.missing", MissingFormatMockFormatter
+          end
+          expect(klass.registered?("mock.missing")).to be_falsy
+          expect(logs).to contains_log :error, \
+            "'MissingFormatMockFormatter does not have a format(payload) " \
+            "method' when initializing mock.missing event formatter"
+        end
+      end
 
-      expect(klass.formatter_classes["mock.specific"]).to eq MockFormatter
-      expect(klass.registered?("mock.specific")).to be_truthy
-      expect(klass.formatters["mock.specific"]).to be_instance_of(MockFormatter)
-      expect(klass.formatters["mock.specific"].body).to eq "some value"
-    end
+      context "when the formatter has an format/0 method" do
+        it "does not register the formatter and logs an error" do
+          logs = capture_logs do
+            described_class.register "mock.incorrect", IncorrectFormatMockFormatter
+          end
+          expect(klass.registered?("mock.incorrect")).to be_falsy
+          expect(logs).to contains_log :error, \
+            "'IncorrectFormatMockFormatter does not have a format(payload) " \
+            "method' when initializing mock.incorrect event formatter"
+        end
+      end
 
-    it "does not know a formatter that's not registered" do
-      expect(klass.formatters["nonsense"]).to be_nil
+      context "when formatter has an format/2 method" do
+        it "does not register the formatter and logs an error" do
+          logs = capture_logs do
+            described_class.register "mock.incorrect", IncorrectFormatMock2Formatter
+          end
+          expect(klass.registered?("mock.incorrect")).to be_falsy
+          expect(logs).to contains_log :error, \
+            "'IncorrectFormatMock2Formatter does not have a format(payload) " \
+            "method' when initializing mock.incorrect event formatter"
+        end
+      end
     end
 
-    it "unregistering a formatter if the registered one has the same class" do
-      klass.register("mock.unregister", MockFormatter)
+    context "when registering deprecated formatters" do
+      let(:stdout_stream) { std_stream }
+      let(:deprecated_formatter) do
+        Class.new(Appsignal::EventFormatter) do
+          register "mock.deprecated"
 
-      klass.unregister("mock.unregister", Hash)
-      expect(klass.registered?("mock.unregister")).to be_truthy
+          def format(_payload)
+          end
+        end
+      end
 
-      klass.unregister("mock.unregister", MockFormatter)
-      expect(klass.registered?("mock.unregister")).to be_falsy
-    end
+      it "registers deprecated formatters and logs & prints a warning" do
+        message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
+          "This event formatter will not be loaded. " \
+          "Please update the formatter according to the documentation at: " \
+          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
+
+        logs = capture_logs do
+          capture_stdout(stdout_stream) { deprecated_formatter }
+        end
+        expect(logs).to contains_log :warn, message
+        expect(stdout_stream.read).to include "appsignal WARNING: #{message}"
+
+        expect(klass.deprecated_formatter_classes.keys).to include("mock.deprecated")
+      end
+
+      it "initializes deprecated formatters" do
+        capture_stdout(stdout_stream) { deprecated_formatter }
+        klass.initialize_deprecated_formatters
 
-    it "does not register two formatters for the same name" do
-      expect(Appsignal.logger).to receive(:warn)
-        .with("Formatter for 'mock.twice' already registered, not registering 'MockFormatter'")
-      klass.register("mock.twice", MockFormatter)
-      klass.register("mock.twice", MockFormatter)
+        expect(klass.registered?("mock.deprecated")).to be_truthy
+        expect(klass.formatters["mock.deprecated"]).to be_instance_of(deprecated_formatter)
+        expect(klass.deprecated_formatter_classes["mock.deprecated"]).to eq(deprecated_formatter)
+      end
     end
+  end
 
-    it "does not register deprecated formatters" do
-      message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
-        "This event formatter will not be loaded. " \
-        "Please update the formatter according to the documentation at: " \
-        "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-      expect(Appsignal.logger).to receive(:warn).with(message)
+  describe ".registered?" do
+    context "when checking by name" do
+      context "when there is a formatter with that name" do
+        it "returns true" do
+          klass.register "mock", MockFormatter
+          expect(klass.registered?("mock")).to be_truthy
+        end
+      end
+
+      context "when there is no formatter with that name" do
+        it "returns false" do
+          expect(klass.registered?("nonsense")).to be_falsy
+        end
+      end
+    end
 
-      capture_stdout(out_stream) { deprecated_formatter }
-      expect(output).to include "appsignal WARNING: #{message}"
+    context "when checking by name and class" do
+      context "when there is a formatter with that name and class" do
+        it "returns true" do
+          klass.register "mock", MockFormatter
+          expect(klass.registered?("mock", MockFormatter)).to be_truthy
+        end
+      end
 
-      expect(Appsignal::EventFormatter.deprecated_formatter_classes.keys).to include("mock.deprecated")
+      context "when there is no formatter with that name and class" do
+        it "returns false" do
+          klass.register "mock", MockFormatterDouble
+          expect(klass.registered?("mock", MockFormatter)).to be_falsy
+        end
+      end
     end
+  end
+
+  describe ".unregister" do
+    context "when a formatter with the name is registered" do
+      it "unregisters the formatter has the same class" do
+        klass.register("mock.unregister", MockFormatter)
+        expect(klass.registered?("mock.unregister")).to be_truthy
 
-    it "initializes deprecated formatters" do
-      # Silence deprecation warning
-      capture_stdout(out_stream) { deprecated_formatter }
-      Appsignal::EventFormatter.initialize_deprecated_formatters
+        klass.unregister("mock.unregister", Hash)
+        expect(klass.registered?("mock.unregister")).to be_truthy
 
-      expect(klass.registered?("mock.deprecated")).to be_truthy
+        klass.unregister("mock.unregister", MockFormatter)
+        expect(klass.registered?("mock.unregister")).to be_falsy
+      end
+    end
+
+    context "when a formatter with the same name and class is not registered" do
+      it "unregisters nothing" do
+        expect do
+          expect do
+            klass.unregister("nonse.unregister", MockFormatter)
+          end.to_not(change { klass.formatters })
+        end.to_not(change { klass.formatter_classes })
+      end
     end
   end
 
-  context "calling formatters" do
-    it "returns nil if there is no formatter registered" do
-      expect(klass.format("nonsense", {})).to be_nil
+  describe ".format" do
+    context "when no formatter with the name is registered" do
+      it "returns nil" do
+        expect(klass.format("nonsense", {})).to be_nil
+      end
     end
 
-    it "calls the formatter if it is registered and use a value set in the initializer" do
-      expect(klass.format("mock", {})).to eq ["title", "some value"]
+    context "when a formatter with the name is registered" do
+      it "calls the formatter and use a value set in the initializer" do
+        klass.register "mock", MockFormatter
+        expect(klass.format("mock", {})).to eq ["title", "some value"]
+      end
     end
   end
 end