appsignal 2.9.2.alpha.1 → 2.9.18.beta.2

data/lib/appsignal/utils/rails_helper.rb

@@ -11,6 +11,10 @@ module Appsignal
           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.9.2.alpha.1".freeze
+  VERSION = "2.9.18.beta.2".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/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
@@ -260,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
@@ -410,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
 

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

@@ -116,6 +116,9 @@ describe Appsignal::CLI::NotifyOfDeploy do
 
       context "with required options" do
         let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
+        let(:log_stream) { std_stream }
+        let(:log) { log_contents(log_stream) }
+        before { Appsignal.logger = test_logger(log_stream) }
 
         it "notifies of a deploy" do
           run
@@ -124,6 +127,13 @@ describe Appsignal::CLI::NotifyOfDeploy do
           expect(output).to include_deploy_notification_with(options)
         end
 
+        it "prints a deprecation message" do
+          run
+          deprecation_message = "This command (appsignal notify_of_deploy) has been deprecated"
+          expect(output).to include("appsignal WARNING: #{deprecation_message}")
+          expect(log).to contains_log :warn, deprecation_message
+        end
+
         context "with no app name configured" do
           before { ENV["APPSIGNAL_APP_NAME"] = "" }
 

data/spec/lib/appsignal/config_spec.rb

@@ -134,6 +134,7 @@ describe Appsignal::Config do
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :dns_servers                    => [],
         :files_world_accessible         => true,
+        :transaction_debug_mode         => false,
         :revision                       => "v2.5.1",
         :request_headers                => []
       )
@@ -202,14 +203,16 @@ describe Appsignal::Config do
   context "with a config file" do
     let(:config) { project_fixture_config("production") }
 
-    it "is not valid or active" do
-      expect(config.valid?).to be_truthy
-      expect(config.active?).to be_truthy
-    end
+    context "with valid config" do
+      it "is valid and active" do
+        expect(config.valid?).to be_truthy
+        expect(config.active?).to be_truthy
+      end
 
-    it "does not log an error" do
-      expect_any_instance_of(Logger).to_not receive(:error)
-      config
+      it "does not log an error" do
+        log = capture_logs { config }
+        expect(log).to_not contains_log(:error)
+      end
     end
 
     it "sets the file_config" do
@@ -471,13 +474,14 @@ describe Appsignal::Config do
       config[:filter_parameters] = %w[password confirm_password]
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
+      config[:transaction_debug_mode] = true
       config[:revision] = "v2.5.1"
       config.write_to_environment
     end
 
     it "writes the current config to environment variables" do
       expect(ENV["_APPSIGNAL_ACTIVE"]).to                       eq "true"
-      expect(ENV["_APPSIGNAL_APP_PATH"]).to                     end_with("spec/support/project_fixture")
+      expect(ENV["_APPSIGNAL_APP_PATH"]).to                     end_with("spec/support/fixtures/projects/valid")
       expect(ENV["_APPSIGNAL_AGENT_PATH"]).to                   end_with("/ext")
       expect(ENV["_APPSIGNAL_DEBUG_LOGGING"]).to                eq "false"
       expect(ENV["_APPSIGNAL_LOG"]).to                          eq "stdout"
@@ -498,6 +502,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_CA_FILE_PATH"]).to                 eq File.join(resources_dir, "cacert.pem")
       expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
+      expect(ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]).to       eq "true"
       expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")

data/spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb

@@ -1,43 +1,53 @@
-if DependencyHelper.rails_present?
-  require "action_view"
+describe Appsignal::EventFormatter::ActionView::RenderFormatter do
+  let(:klass) { Appsignal::EventFormatter::ActionView::RenderFormatter }
 
-  describe Appsignal::EventFormatter::ActionView::RenderFormatter do
-    before { allow(Rails.root).to receive(:to_s).and_return("/var/www/app/20130101") }
-    let(:klass) { Appsignal::EventFormatter::ActionView::RenderFormatter }
-    let(:formatter) { klass.new }
+  if DependencyHelper.rails_present?
+    require "action_view"
 
-    it "should register render_partial.action_view and render_template.action_view" do
-      expect(Appsignal::EventFormatter.registered?("render_partial.action_view", klass)).to be_truthy
-      expect(Appsignal::EventFormatter.registered?("render_template.action_view", klass)).to be_truthy
-    end
+    context "when in a Rails app" do
+      let(:formatter) { klass.new }
+      before { allow(Rails.root).to receive(:to_s).and_return("/var/www/app/20130101") }
+
+      it "registers render_partial.action_view and render_template.action_view" do
+        expect(Appsignal::EventFormatter.registered?("render_partial.action_view", klass)).to be_truthy
+        expect(Appsignal::EventFormatter.registered?("render_template.action_view", klass)).to be_truthy
+      end
 
-    describe "#root_path" do
-      subject { formatter.root_path }
+      describe "#root_path" do
+        subject { formatter.root_path }
 
-      it "returns Rails root path" do
-        is_expected.to eq "/var/www/app/20130101/"
+        it "returns Rails root path" do
+          is_expected.to eq "/var/www/app/20130101/"
+        end
       end
-    end
 
-    describe "#format" do
-      subject { formatter.format(payload) }
+      describe "#format" do
+        subject { formatter.format(payload) }
 
-      context "with an identifier" do
-        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb" } }
+        context "with an identifier" do
+          let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb" } }
 
-        it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
-      end
+          it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
+        end
 
-      context "with a frozen identifier" do
-        let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb".freeze } }
+        context "with a frozen identifier" do
+          let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb".freeze } }
 
-        it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
-      end
+          it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
+        end
 
-      context "without an identifier" do
-        let(:payload) { {} }
+        context "without an identifier" do
+          let(:payload) { {} }
 
-        it { is_expected.to be_nil }
+          it { is_expected.to be_nil }
+        end
+      end
+    end
+  else
+    context "when not in a Rails app" do
+      it "does not register the event formatter" do
+        expect(Appsignal::EventFormatter.registered?("render_partial.action_view", klass)).to be_falsy
+        expect(Appsignal::EventFormatter.registered?("render_template.action_view", klass)).to be_falsy
       end
     end
   end

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

@@ -2,12 +2,14 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
     let(:as) { ActiveSupport::Notifications }
+    let!(:transaction) do
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+    end
     before :context do
       start_agent
     end
     before do
       as.notifier = notifier
-      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
     end
 
     describe "#dependencies_present?" do
@@ -17,27 +19,71 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
     end
 
     it "instruments an ActiveSupport::Notifications.instrument event" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("sql.active_record", nil, "SQL", 1)
-
       return_value = as.instrument("sql.active_record", :sql => "SQL") do
         "value"
       end
 
       expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
-    it "should convert non-string names to strings" do
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("not_a_string", nil, nil, nil)
+    it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
+      return_value = as.instrument("no-registered.formatter", :key => "something") do
+        "value"
+      end
+
+      expect(return_value).to eq "value"
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "no-registered.formatter",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
 
+    it "converts non-string names to strings" do
       as.instrument(:not_a_string) {}
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "not_a_string",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
     end
 
     it "does not instrument events whose name starts with a bang" do
@@ -53,33 +99,66 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
 
     context "when an error is raised in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             raise ExampleException, "foo"
           end
         end.to raise_error(ExampleException, "foo")
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
       end
     end
 
     context "when a message is thrown in an instrumented block" do
       it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect(Appsignal::Transaction.current).to receive(:start_event)
-          .at_least(:once)
-        expect(Appsignal::Transaction.current).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.active_record", nil, "SQL", 1)
-
         expect do
           as.instrument("sql.active_record", :sql => "SQL") do
             throw :foo
           end
         end.to throw_symbol(:foo)
+
+        expect(transaction.to_h["events"]).to match([
+          {
+            "allocation_count" => kind_of(Integer),
+            "body" => "SQL",
+            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "duration" => kind_of(Float),
+            "gc_duration" => kind_of(Float),
+            "name" => "sql.active_record",
+            "start" => kind_of(Float),
+            "title" => ""
+          }
+        ])
+      end
+    end
+
+    context "when a transaction is completed in an instrumented block" do
+      it "does not complete the ActiveSupport::Notifications.instrument event" do
+        expect(transaction).to receive(:complete)
+        as.instrument("sql.active_record", :sql => "SQL") do
+          Appsignal::Transaction.complete_current!
+        end
+
+        expect(transaction.to_h["events"]).to match([])
       end
     end
   else