appsignal 2.8.4.beta.1 → 2.9.18.beta.1

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/transaction.rb

@@ -264,6 +264,11 @@ module Appsignal
     end
 
     def set_error(error)
+      unless error.is_a?(Exception)
+        Appsignal.logger.error "Appsignal::Transaction#set_error: Cannot set error. " \
+          "The given value is not an exception: #{error.inspect}"
+        return
+      end
       return unless error
       return unless Appsignal.active?
 
@@ -277,10 +282,12 @@ module Appsignal
     alias_method :add_exception, :set_error
 
     def start_event
+      return if paused?
       @ext.start_event(self.class.garbage_collection_profiler.total_time)
     end
 
     def finish_event(name, title, body, body_format = Appsignal::EventFormatter::DEFAULT)
+      return if paused?
       @ext.finish_event(
         name,
         title || BLANK,
@@ -291,6 +298,7 @@ module Appsignal
     end
 
     def record_event(name, title, body, duration, body_format = Appsignal::EventFormatter::DEFAULT)
+      return if paused?
       @ext.record_event(
         name,
         title || BLANK,

data/lib/appsignal/utils/rails_helper.rb

@@ -0,0 +1,20 @@
+# 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
+
+      def self.application_config_path
+        File.expand_path(File.join(Dir.pwd, "config/application.rb"))
+      end
+    end
+  end
+end

data/lib/appsignal/version.rb

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

data/lib/puma/plugin/appsignal.rb

@@ -0,0 +1,26 @@
+APPSIGNAL_PUMA_PLUGIN_LOADED = true
+
+# AppSignal Puma plugin
+#
+# This plugin ensures the minutely probe thread is started with the Puma
+# minutely probe in the Puma master process.
+#
+# The constant {APPSIGNAL_PUMA_PLUGIN_LOADED} is here to mark the Plugin as
+# loaded by the rest of the AppSignal gem. This ensures that the Puma minutely
+# probe is not also started in every Puma workers, which was the old behavior.
+# See {Appsignal::Hooks::PumaHook#install} for more information.
+#
+# For even more information:
+# https://docs.appsignal.com/ruby/integrations/puma.html
+Puma::Plugin.create do
+  def start(launcher = nil)
+    launcher.events.on_booted do
+      require "appsignal"
+      if ::Puma.respond_to?(:stats)
+        Appsignal::Minutely.probes.register :puma, Appsignal::Hooks::PumaProbe
+      end
+      Appsignal.start
+      Appsignal.start_logger
+    end
+  end
+end

data/spec/lib/appsignal/cli/diagnose/utils_spec.rb

@@ -1,6 +1,46 @@
 require "appsignal/cli/diagnose/utils"
 
 describe Appsignal::CLI::Diagnose::Utils do
+  describe ".username_for_uid" do
+    subject { described_class.username_for_uid(uid) }
+
+    context "when user with id exists" do
+      let(:uid) { 0 }
+
+      it "returns username" do
+        is_expected.to be_kind_of(String)
+      end
+    end
+
+    context "when user with id does not exist" do
+      let(:uid) { -1 }
+
+      it "returns nil" do
+        is_expected.to be_nil
+      end
+    end
+  end
+
+  describe ".group_for_gid" do
+    subject { described_class.group_for_gid(uid) }
+
+    context "when group with id exists" do
+      let(:uid) { 0 }
+
+      it "returns group name" do
+        is_expected.to be_kind_of(String)
+      end
+    end
+
+    context "when group with id does not exist" do
+      let(:uid) { -3 }
+
+      it "returns nil" do
+        is_expected.to be_nil
+      end
+    end
+  end
+
   describe ".read_file_content" do
     let(:path) { File.join(spec_system_tmp_dir, "test_file.txt") }
     let(:bytes_to_read) { 100 }

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

@@ -16,6 +16,10 @@ describe Appsignal::CLI::Install do
     allow(described_class).to receive(:press_any_key)
     allow(Appsignal::Demo).to receive(:transmit).and_return(true)
   end
+  after do
+    FileUtils.rm_rf(tmp_dir)
+    FileUtils.mkdir_p(tmp_dir)
+  end
   around do |example|
     original_stdin = $stdin
     $stdin = StringIO.new
@@ -157,16 +161,10 @@ describe Appsignal::CLI::Install do
   shared_examples "capistrano install" do
     let(:capfile) { File.join(tmp_dir, "Capfile") }
     before do
-      FileUtils.mkdir_p(tmp_dir)
-
       enter_app_name "foo"
       add_cli_input "n"
       choose_environment_config
     end
-    after do
-      FileUtils.rm_rf(tmp_dir)
-      FileUtils.mkdir_p(tmp_dir)
-    end
 
     context "without Capfile" do
       it "does nothing" do
@@ -243,7 +241,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") }
@@ -255,7 +258,6 @@ describe Appsignal::CLI::Install do
         FileUtils.touch(File.join(environments_dir, "development.rb"))
         FileUtils.touch(File.join(environments_dir, "staging.rb"))
         FileUtils.touch(File.join(environments_dir, "production.rb"))
-        enter_app_name app_name
       end
 
       describe "environments" do
@@ -405,6 +407,53 @@ describe Appsignal::CLI::Install do
           end
         end
       end
+
+      context "when there is no Rails application.rb file" do
+        before do
+          # Do not detect it as another framework for testing
+          allow(described_class).to receive(:framework_available?).and_call_original
+          allow(described_class).to receive(:framework_available?).with("sinatra").and_return(false)
+
+          File.delete(File.join(config_dir, "application.rb"))
+          expect(File.exist?(File.join(config_dir, "application.rb"))).to eql(false)
+        end
+
+        it "fails the installation" do
+          run
+
+          expect(output).to include("We could not detect which framework you are using.")
+          expect(output).to_not include("Installing for Ruby on Rails")
+          expect(output).to include_complete_install
+
+          expect(File.exist?(config_file_path)).to be(false)
+        end
+      end
+
+      context "when failed to load the Rails application.rb file" do
+        before do
+          File.open(File.join(config_dir, "application.rb"), "w") do |file|
+            file.write("I am invalid code")
+          end
+        end
+
+        it "prompts the user to fill in an app name" do
+          enter_app_name app_name
+          choose_config_file
+          run
+
+          expect(output).to include("Installing for Ruby on Rails")
+          expect(output).to include("Unable to automatically detect your Rails app's name.")
+          expect(output).to include("Choose your app's display name for AppSignal.com:")
+          expect(output).to include_file_config
+          expect(output).to include_complete_install
+
+          expect(config_file).to configure_app_name(app_name)
+          expect(config_file).to configure_push_api_key(push_api_key)
+          expect(config_file).to configure_environment("development")
+          expect(config_file).to configure_environment("staging")
+          expect(config_file).to configure_environment("production")
+        end
+      end
     end
   end