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

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

@@ -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,
@@ -202,14 +202,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
@@ -218,7 +220,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
 
@@ -476,7 +479,7 @@ describe Appsignal::Config do
 
     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"
@@ -492,7 +495,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/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/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