appsignal 1.4.0.alpha.2 → 1.4.0.beta.1

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

@@ -1,27 +1,29 @@
-require 'spec_helper'
 require 'appsignal/cli'
 
 describe Appsignal::CLI::Diagnose do
   let(:out_stream) { StringIO.new }
-  let(:cli) { Appsignal::CLI::Diagnose }
-  before do
-    @original_stdout = $stdout
-    $stdout = out_stream
-  end
-  after do
-    $stdout = @original_stdout
+  let(:config) { project_fixture_config }
+  let(:cli) { described_class }
+  around do |example|
+    capture_stdout(out_stream) { example.run }
   end
 
   describe ".run" do
+    before do
+      Appsignal.config = config
+      stub_api_request config, 'auth'
+    end
+
     it "should output diagnostic information" do
       cli.run
-
-      out_stream.string.should include('Gem version')
-      out_stream.string.should include('Agent version')
-      out_stream.string.should include('Config')
-      out_stream.string.should include('Checking API key')
-      out_stream.string.should include('Checking if required paths are writable')
-      out_stream.string.should include('Showing last lines of extension install log')
+      output = out_stream.string
+      expect(output).to include('Gem version')
+      expect(output).to include('Agent version')
+      expect(output).to include('Environment')
+      expect(output).to include('Config')
+      expect(output).to include('Checking API key')
+      expect(output).to include('Checking if required paths are writable')
+      expect(output).to include('Showing last lines of extension install log')
     end
   end
 end

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

@@ -1,11 +1,5 @@
-require 'spec_helper'
 require 'appsignal/cli'
 
-begin
-  require 'sinatra'
-rescue LoadError
-end
-
 describe Appsignal::CLI::Install do
   let(:out_stream) { StringIO.new }
   let(:cli) { Appsignal::CLI::Install }
@@ -14,15 +8,13 @@ describe Appsignal::CLI::Install do
 
   before do
     Dir.stub(:pwd => project_fixture_path)
-    @original_stdout = $stdout
-    $stdout = out_stream
     Appsignal::AuthCheck.stub(:new => auth_check)
     auth_check.stub(:perform => '200')
     cli.stub(:sleep)
     cli.stub(:press_any_key)
   end
-  after do
-    $stdout = @original_stdout
+  around do |example|
+    capture_stdout(out_stream) { example.run }
   end
 
   describe ".run" do
@@ -375,24 +367,50 @@ describe Appsignal::CLI::Install do
       end
     end
 
-    context "when deploy.rb is present" do
-      let(:config_dir) { File.join(tmp_dir, 'config') }
-      let(:deploy_rb_file) { File.join(tmp_dir, 'config/deploy.rb') }
+    context "with capistrano" do
+      let(:capfile) { File.join(tmp_dir, 'Capfile') }
       before do
         Dir.stub(:pwd => tmp_dir)
-        FileUtils.mkdir_p(config_dir)
-        FileUtils.touch(deploy_rb_file)
+        FileUtils.mkdir_p(tmp_dir)
         cli.should_receive(:gets).once.and_return('2')
       end
       after do
-        FileUtils.rm_rf(config_dir)
+        FileUtils.rm_rf(tmp_dir)
       end
 
-      it "should add a require to deploy.rb" do
-        cli.configure(config, [], false)
+      context "without Capfile" do
+        before { cli.configure(config, [], false) }
+
+        it "does nothing" do
+          expect(out_stream.string).to_not include 'Adding AppSignal integration to Capfile'
+          expect(File.exist?(capfile)).to be_false
+        end
+      end
+
+      context "with Capfile" do
+        context "when already installed" do
+          before do
+            File.open(capfile, 'w') { |f| f.write("require 'appsignal/capistrano'") }
+            cli.configure(config, [], false)
+          end
+
+          it "does not add another require to Capfile" do
+            expect(out_stream.string).to_not include 'Adding AppSignal integration to Capfile'
+            expect(File.read(capfile).scan(/appsignal/).count).to eq(1)
+          end
+        end
 
-        out_stream.string.should include 'Adding AppSignal integration to deploy.rb'
-        File.read(deploy_rb_file).should include "require 'appsignal/capistrano'"
+        context "when not installed" do
+          before do
+            FileUtils.touch(capfile)
+            cli.configure(config, [], false)
+          end
+
+          it "adds a require to Capfile" do
+            expect(out_stream.string).to include 'Adding AppSignal integration to Capfile'
+            expect(File.read(capfile)).to include "require 'appsignal/capistrano'"
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'appsignal/cli'
 
 describe Appsignal::CLI::NotifyOfDeploy do
@@ -7,12 +6,10 @@ describe Appsignal::CLI::NotifyOfDeploy do
   let(:config) { Appsignal::Config.new(project_fixture_path, {}) }
   let(:marker_data) { {:revision => 'aaaaa', :user => 'thijs', :environment => 'production'} }
   before do
-    @original_stdout = $stdout
-    $stdout = out_stream
     config.stub(:active? => true)
   end
-  after do
-    $stdout = @original_stdout
+  around do |example|
+    capture_stdout(out_stream) { example.run }
   end
 
   describe ".run" do

data/spec/lib/appsignal/cli_spec.rb

@@ -1,17 +1,14 @@
-require 'spec_helper'
 require 'appsignal/cli'
 
 describe Appsignal::CLI do
   let(:out_stream) { StringIO.new }
   let(:cli) { Appsignal::CLI }
   before do
-    @original_stdout = $stdout
-    $stdout = out_stream
     Dir.stub(:pwd => project_fixture_path)
     cli.options = {:environment => 'production'}
   end
-  after do
-    $stdout = @original_stdout
+  around do |example|
+    capture_stdout(out_stream) { example.run }
   end
 
   describe "#config" do

data/spec/lib/appsignal/config_spec.rb

@@ -1,22 +1,50 @@
-require 'spec_helper'
-
 describe Appsignal::Config do
-  subject { config }
+  describe "config based on the system" do
+    let(:config) { project_fixture_config(:none) }
 
-  describe "with a config file" do
-    let(:config) { project_fixture_config('production') }
+    describe ":running_in_container" do
+      subject { config[:running_in_container] }
+
+      context "when running on Heroku" do
+        around { |example| recognize_as_heroku { example.run } }
+
+        it "is set to true" do
+          expect(subject).to be_true
+        end
+      end
+
+      context "when running in container" do
+        around { |example| recognize_as_container(:docker) { example.run } }
 
-    it "should not log an error" do
-      Logger.any_instance.should_not_receive(:log_error)
-      subject
+        it "is set to true" do
+          expect(subject).to be_true
+        end
+      end
+
+      context "when not running in container" do
+        around { |example| recognize_as_container(:none) { example.run } }
+
+        it "is set to false" do
+          expect(subject).to be_false
+        end
+      end
     end
+  end
 
-    its(:valid?)        { should be_true }
-    its(:active?)       { should be_true }
-    its(:log_file_path) { should end_with('spec/support/project_fixture/appsignal.log') }
+  describe "initial config" do
+    let(:config) do
+      described_class.new(
+        "non-existing-path",
+        "production",
+        :push_api_key => "abc",
+        :name => "TestApp",
+        :active => true
+      )
+    end
+    around { |example| recognize_as_container(:none) { example.run } }
 
-    it "should merge with the default config and fill the config hash" do
-      subject.config_hash.should eq({
+    it "merges with the default config" do
+      expect(config.config_hash).to eq(
         :debug                          => false,
         :ignore_errors                  => [],
         :ignore_actions                 => [],
@@ -37,221 +65,420 @@ describe Appsignal::Config do
         :running_in_container           => false,
         :enable_host_metrics            => true,
         :enable_minutely_probes         => false,
-        :hostname                       => Socket.gethostname
-      })
+        :hostname                       => Socket.gethostname,
+        :ca_file_path                   => File.join(resources_dir, 'cacert.pem')
+      )
     end
 
-    context "if a log file path is set" do
-      let(:config) { project_fixture_config('production', :log_path => '/tmp') }
+    describe "overriding system detected config" do
+      let(:config) do
+        described_class.new(
+          "non-existing-path",
+          "production",
+          :running_in_container => true
+        )
+      end
 
-      its(:log_file_path) { should end_with('/tmp/appsignal.log') }
+      it "overrides system detected config" do
+        expect(config[:running_in_container]).to be_true
+      end
+    end
+  end
 
-      context "if it is not writable" do
-        before { FileUtils.mkdir_p('/tmp/not-writable', :mode => 0555) }
+  context "when root path is nil" do
+    let(:config) { described_class.new(nil, 'production') }
 
-        let(:config) { project_fixture_config('production', :log_path => '/tmp/not-writable') }
+    it "is not valid or active" do
+      expect(config.valid?).to be_false
+      expect(config.active?).to be_false
+    end
+  end
 
-        its(:log_file_path) { should eq '/tmp/appsignal.log' }
-      end
+  context "without config file" do
+    let(:config) { described_class.new(tmp_dir, 'production') }
 
-      context "if it does not exist" do
-        let(:config) { project_fixture_config('production', :log_path => '/non-existing') }
+    it "is not valid or active" do
+      expect(config.valid?).to be_false
+      expect(config.active?).to be_false
+    end
+  end
 
-        its(:log_file_path) { should eq '/tmp/appsignal.log' }
-      end
+  context "with a config file" do
+    let(:config) { project_fixture_config('production') }
 
-      context "if it is nil" do
-        let(:config) { project_fixture_config('production', :log_path => nil) }
+    it "is not valid or active" do
+      expect(config.valid?).to be_true
+      expect(config.active?).to be_true
+    end
+
+    it "does not log an error" do
+      expect_any_instance_of(Logger).to_not receive(:error)
+      config
+    end
 
-        before { config.stub(:root_path => nil) }
+    describe "overriding system and defaults config" do
+      let(:config) do
+        described_class.new(
+          "non-existing-path",
+          "production",
+          :running_in_container => true,
+          :debug => true
+        )
+      end
+      around { |example| recognize_as_container(:none) { example.run } }
 
-        its(:log_file_path) { should eq '/tmp/appsignal.log' }
+      it "overrides system detected and defaults config" do
+        expect(config[:running_in_container]).to be_true
+        expect(config[:debug]).to be_true
       end
     end
 
-    context "when there is a pre 0.12 style endpoint" do
-      let(:config) { project_fixture_config('production', :endpoint => 'https://push.appsignal.com/1') }
+    context "with the env name as a symbol" do
+      let(:config) { project_fixture_config(:production) }
+
+      it "loads the config" do
+        expect(config.valid?).to be_true
+        expect(config.active?).to be_true
 
-      it "should strip the path" do
-        subject[:endpoint].should eq 'https://push.appsignal.com'
+        expect(config[:push_api_key]).to eq('abc')
       end
     end
 
-    context "when there is an endpoint with a non-standard port" do
-      let(:config) { project_fixture_config('production', :endpoint => 'http://localhost:4567') }
+    context "without the selected env" do
+      let(:config) { project_fixture_config('nonsense') }
 
-      it "should keep the port" do
-        subject[:endpoint].should eq 'http://localhost:4567'
+      it "is not valid or active" do
+        expect(config.valid?).to be_false
+        expect(config.active?).to be_false
+      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
       end
     end
 
-    describe "#[]= and #[]" do
-      it "should get the value for an existing key" do
-        subject[:push_api_key].should eq 'abc'
+    describe "old-style config keys" do
+      describe ":api_key" do
+        subject { config[:push_api_key] }
+
+        context "without :push_api_key" do
+          let(:config) { project_fixture_config('old_config') }
+
+          it "sets the :push_api_key with the old :api_key value" do
+            expect(subject).to eq 'def'
+          end
+        end
+
+        context "with :push_api_key" do
+          let(:config) { project_fixture_config('old_config_mixed_with_new_config') }
+
+          it "ignores the :api_key config" do
+            expect(subject).to eq 'ghi'
+          end
+        end
       end
 
-      it "should change and get the value for an existing key" do
-        subject[:push_api_key] = 'abcde'
-        subject[:push_api_key].should eq 'abcde'
+      describe ":ignore_exceptions" do
+        subject { config[:ignore_errors] }
+
+        context "without :ignore_errors" do
+          let(:config) { project_fixture_config('old_config') }
+
+          it "sets :ignore_errors with the old :ignore_exceptions value" do
+            expect(subject).to eq ['StandardError']
+          end
+        end
+
+        context "with :ignore_errors" do
+          let(:config) { project_fixture_config('old_config_mixed_with_new_config') }
+
+          it "ignores the :ignore_exceptions config" do
+            expect(subject).to eq ['NoMethodError']
+          end
+        end
+      end
+    end
+  end
+
+  context "with config in the environment" do
+    let(:config) do
+      described_class.new(
+        "non-existing-path",
+        "production",
+        :running_in_container => true,
+        :debug => true
+      )
+    end
+    before do
+      ENV['APPSIGNAL_RUNNING_IN_CONTAINER'] = 'true'
+      ENV['APPSIGNAL_PUSH_API_KEY']         = 'aaa-bbb-ccc'
+      ENV['APPSIGNAL_ACTIVE']               = 'true'
+      ENV['APPSIGNAL_APP_NAME']             = 'App name'
+      ENV['APPSIGNAL_DEBUG']                = 'true'
+      ENV['APPSIGNAL_IGNORE_ACTIONS']       = 'action1,action2'
+    end
+    around { |example| recognize_as_container(:none) { example.run } }
+
+    it "overrides config with environment values" do
+      expect(config.valid?).to be_true
+      expect(config.active?).to be_true
+
+      expect(config[:running_in_container]).to be_true
+      expect(config[:push_api_key]).to eq 'aaa-bbb-ccc'
+      expect(config[:active]).to be_true
+      expect(config[:name]).to eq 'App name'
+      expect(config[:debug]).to be_true
+      expect(config[:ignore_actions]).to eq ['action1', 'action2']
+    end
+  end
+
+  describe "config keys" do
+    describe ":endpoint" do
+      subject { config[:endpoint] }
+
+      context "with an pre-0.12-style endpoint" do
+        let(:config) do
+          project_fixture_config('production', :endpoint => 'https://push.appsignal.com/1')
+        end
+
+        it "strips off the path" do
+          expect(subject).to eq 'https://push.appsignal.com'
+        end
       end
 
-      it "should return nil for a non-existing key" do
-        subject[:nonsense].should be_nil
+      context "with a non-standard port" do
+        let(:config) { project_fixture_config('production', :endpoint => 'http://localhost:4567') }
+
+        it "keeps the port" do
+          expect(subject).to eq 'http://localhost:4567'
+        end
       end
     end
+  end
 
-    describe "#write_to_environment" do
-      before do
-        subject.config_hash[:http_proxy]     = 'http://localhost'
-        subject.config_hash[:ignore_actions] = ['action1', 'action2']
-        subject.config_hash[:log_path]  = '/tmp'
-        subject.config_hash[:hostname]  = 'app1.local'
-        subject.config_hash[:filter_parameters] = %w(password confirm_password)
-        subject.write_to_environment
+  describe "#[]" do
+    let(:config) { project_fixture_config(:none, :push_api_key => 'foo') }
+
+    context "with existing key" do
+      it "gets the value" do
+        expect(config[:push_api_key]).to eq 'foo'
       end
+    end
 
-      it "should write the current config to env vars" do
-        ENV['APPSIGNAL_ACTIVE'].should                       eq 'true'
-        ENV['APPSIGNAL_APP_PATH'].should                     end_with('spec/support/project_fixture')
-        ENV['APPSIGNAL_AGENT_PATH'].should                   end_with('/ext')
-        ENV['APPSIGNAL_DEBUG_LOGGING'].should                eq 'false'
-        ENV['APPSIGNAL_LOG_FILE_PATH'].should                end_with('/tmp/appsignal.log')
-        ENV['APPSIGNAL_PUSH_API_ENDPOINT'].should            eq 'https://push.appsignal.com'
-        ENV['APPSIGNAL_PUSH_API_KEY'].should                 eq 'abc'
-        ENV['APPSIGNAL_APP_NAME'].should                     eq 'TestApp'
-        ENV['APPSIGNAL_ENVIRONMENT'].should                  eq 'production'
-        ENV['APPSIGNAL_AGENT_VERSION'].should                eq Appsignal::Extension.agent_version
-        ENV['APPSIGNAL_LANGUAGE_INTEGRATION_VERSION'].should eq Appsignal::VERSION
-        ENV['APPSIGNAL_HTTP_PROXY'].should                   eq 'http://localhost'
-        ENV['APPSIGNAL_IGNORE_ACTIONS'].should               eq 'action1,action2'
-        ENV['APPSIGNAL_FILTER_PARAMETERS'].should            eq 'password,confirm_password'
-        ENV['APPSIGNAL_SEND_PARAMS'].should                  eq 'true'
-        ENV['APPSIGNAL_RUNNING_IN_CONTAINER'].should         eq 'false'
-        ENV['APPSIGNAL_WORKING_DIR_PATH'].should             be_nil
-        ENV['APPSIGNAL_ENABLE_HOST_METRICS'].should          eq 'true'
-        ENV['APPSIGNAL_ENABLE_MINUTELY_PROBES'].should       eq 'false'
-        ENV['APPSIGNAL_HOSTNAME'].should                     eq 'app1.local'
-        ENV['APPSIGNAL_PROCESS_NAME'].should                 include 'rspec'
+    context "without existing key" do
+      it "returns nil" do
+        expect(config[:nonsense]).to be_nil
       end
+    end
+  end
 
-      context "if working_dir_path is set" do
-        before do
-          subject.config_hash[:working_dir_path] = '/tmp/appsignal2'
-          subject.write_to_environment
-        end
+  describe "#[]=" do
+    let(:config) { project_fixture_config(:none) }
 
-        it "should write the current config to env vars" do
-          ENV['APPSIGNAL_WORKING_DIR_PATH'].should eq '/tmp/appsignal2'
-        end
+    context "with existing key" do
+      it "changes the value" do
+        expect(config[:push_api_key]).to be_nil
+        config[:push_api_key] = 'abcde'
+        expect(config[:push_api_key]).to eq 'abcde'
       end
     end
 
-    context "if the env is passed as a symbol" do
-      let(:config) { project_fixture_config(:production) }
+    context "with new key" do
+      it "sets the value" do
+        expect(config[:foo]).to be_nil
+        config[:foo] = 'bar'
+        expect(config[:foo]).to eq 'bar'
+      end
+    end
+  end
+
+  describe "#write_to_environment" do
+    let(:config) { project_fixture_config(:production) }
+    before do
+      config[:http_proxy] = 'http://localhost'
+      config[:ignore_actions] = ['action1', 'action2']
+      config[:log_path] = '/tmp'
+      config[:hostname] = 'app1.local'
+      config[:filter_parameters] = %w(password confirm_password)
+      config[:running_in_container] = false
+      config.write_to_environment
+    end
 
-      its(:active?) { should be_true }
+    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_AGENT_PATH']).to                   end_with('/ext')
+      expect(ENV['APPSIGNAL_DEBUG_LOGGING']).to                eq 'false'
+      expect(ENV['APPSIGNAL_LOG_FILE_PATH']).to                end_with('/tmp/appsignal.log')
+      expect(ENV['APPSIGNAL_PUSH_API_ENDPOINT']).to            eq 'https://push.appsignal.com'
+      expect(ENV['APPSIGNAL_PUSH_API_KEY']).to                 eq 'abc'
+      expect(ENV['APPSIGNAL_APP_NAME']).to                     eq 'TestApp'
+      expect(ENV['APPSIGNAL_ENVIRONMENT']).to                  eq 'production'
+      expect(ENV['APPSIGNAL_AGENT_VERSION']).to                eq Appsignal::Extension.agent_version
+      expect(ENV['APPSIGNAL_LANGUAGE_INTEGRATION_VERSION']).to eq Appsignal::VERSION
+      expect(ENV['APPSIGNAL_HTTP_PROXY']).to                   eq 'http://localhost'
+      expect(ENV['APPSIGNAL_IGNORE_ACTIONS']).to               eq 'action1,action2'
+      expect(ENV['APPSIGNAL_FILTER_PARAMETERS']).to            eq 'password,confirm_password'
+      expect(ENV['APPSIGNAL_SEND_PARAMS']).to                  eq 'true'
+      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 'app1.local'
+      expect(ENV['APPSIGNAL_PROCESS_NAME']).to                 include 'rspec'
+      expect(ENV['APPSIGNAL_CA_FILE_PATH']).to                 eq File.join(resources_dir, "cacert.pem")
+      expect(ENV).to_not                                       have_key('APPSIGNAL_WORKING_DIR_PATH')
     end
 
-    context "and there's config in the environment" do
+    context "with :working_dir_path" do
       before do
-        ENV['APPSIGNAL_PUSH_API_KEY'] = 'push_api_key'
-        ENV['APPSIGNAL_DEBUG'] = 'true'
+        config[:working_dir_path] = '/tmp/appsignal2'
+        config.write_to_environment
       end
 
-      it "should ignore env vars that are present in the config file" do
-        subject[:push_api_key].should eq 'abc'
+      it "sets the modified :working_dir_path" do
+        expect(ENV['APPSIGNAL_WORKING_DIR_PATH']).to eq '/tmp/appsignal2'
+      end
+    end
+  end
+
+  describe "#log_file_path" do
+    let(:stdout) { StringIO.new }
+    let(:config) { project_fixture_config('production', :log_path => log_path) }
+    subject { config.log_file_path }
+    around { |example| capture_stdout(stdout) { example.run } }
+
+    context "when path is writable" do
+      let(:log_path) { File.join(tmp_dir, 'writable-path') }
+      before { FileUtils.mkdir_p(log_path, :mode => 0755) }
+      after { FileUtils.rm_rf(log_path) }
+
+      it "returns log file path" do
+        expect(subject).to eq File.join(log_path, 'appsignal.log')
       end
 
-      it "should use env vars that are not present in the config file" do
-        subject[:debug].should eq true
+      it "prints no warning" do
+        subject
+        expect(stdout.string).to be_empty
       end
+    end
 
-      context "running on Heroku" do
-        before do
-          ENV['DYNO'] = 'true'
-        end
-        after do
-          ENV.delete('DYNO')
+    shared_examples '#log_file_path: tmp path' do
+      let(:system_tmp_dir) { described_class::SYSTEM_TMP_DIR }
+      before { FileUtils.mkdir_p(system_tmp_dir) }
+      after { FileUtils.rm_rf(system_tmp_dir) }
+
+      context "when the /tmp fallback path is writable" do
+        before { FileUtils.chmod(0777, system_tmp_dir) }
+
+        it "returns returns the tmp location" do
+          expect(subject).to eq(File.join(system_tmp_dir, 'appsignal.log'))
         end
 
-        it "should set running in container to true" do
-          subject[:running_in_container].should be_true
+        it "prints a warning" do
+          subject
+          expect(stdout.string).to include "appsignal: Unable to log to '#{log_path}'. "\
+            "Logging to '#{system_tmp_dir}' instead."
         end
       end
-    end
 
-    context "and there is an initial config" do
-      let(:config) { project_fixture_config('production', :name => 'Initial name', :initial_key => 'value') }
+      context "when the /tmp fallback path is not writable" do
+        before { FileUtils.chmod(0555, system_tmp_dir) }
+
+        it "returns nil" do
+          expect(subject).to be_nil
+        end
 
-      it "should merge with the config" do
-        subject[:name].should eq 'TestApp'
-        subject[:initial_key].should eq 'value'
+        it "prints a warning" do
+          subject
+          expect(stdout.string).to include "appsignal: Unable to log to '#{log_path}' "\
+            "or the '#{system_tmp_dir}' fallback."
+        end
       end
     end
 
-    context "and there is an old-style config" do
-      let(:config) { project_fixture_config('old_api_key') }
+    context "when path is nil" do
+      let(:log_path) { nil }
+
+      context "when root_path is nil" do
+        before { allow(config).to receive(:root_path).and_return(nil) }
 
-      it "should fill the push_api_key with the old style key" do
-        subject[:push_api_key].should eq 'def'
+        include_examples '#log_file_path: tmp path'
       end
 
-      it "should fill ignore_errors with the old style ignore exceptions" do
-        subject[:ignore_errors].should eq ['StandardError']
+      context "when root_path is set" do
+        it "returns returns the project log location" do
+          expect(subject).to eq File.join(config.root_path, 'appsignal.log')
+        end
+
+        it "prints no warning" do
+          subject
+          expect(stdout.string).to be_empty
+        end
       end
     end
-  end
 
-  context "when there is a config file without the current env" do
-    let(:config) { project_fixture_config('nonsense') }
-
-    it "should log an error" do
-      Logger.any_instance.should_receive(:error).with(
-        "Not loading from config file: config for 'nonsense' not found"
-      ).once
-      Logger.any_instance.should_receive(:error).with(
-        "Push api key not set after loading config"
-      ).once
-      subject
+    context "when path does not exist" do
+      let(:log_path) { '/non-existing' }
+
+      include_examples '#log_file_path: tmp path'
     end
 
-    its(:valid?)  { should be_false }
-    its(:active?) { should be_false }
-  end
+    context "when path is not writable" do
+      let(:log_path) { File.join(tmp_dir, 'not-writable-path') }
+      before { FileUtils.mkdir_p(log_path, :mode => 0555) }
+      after { FileUtils.rm_rf(log_path) }
 
-  context "when there is no config file" do
-    let(:initial_config) { {} }
-    let(:config) { Appsignal::Config.new('/tmp', 'production', initial_config) }
+      include_examples '#log_file_path: tmp path'
+    end
 
-    its(:valid?)        { should be_false }
-    its(:active?)       { should be_false }
-    its(:log_file_path) { should end_with('/tmp/appsignal.log') }
+    context "when path is a symlink" do
+      context "when linked path does not exist" do
+        let(:real_path) { File.join(tmp_dir, 'real-path') }
+        let(:log_path) { File.join(tmp_dir, 'symlink-path') }
+        before { File.symlink(real_path, log_path) }
+        after { FileUtils.rm(log_path) }
 
-    context "with valid config in the environment" do
-      before do
-        ENV['APPSIGNAL_PUSH_API_KEY']   = 'aaa-bbb-ccc'
-        ENV['APPSIGNAL_ACTIVE']         = 'true'
-        ENV['APPSIGNAL_APP_NAME']       = 'App name'
-        ENV['APPSIGNAL_DEBUG']          = 'true'
-        ENV['APPSIGNAL_IGNORE_ACTIONS'] = 'action1,action2'
+        include_examples '#log_file_path: tmp path'
       end
 
-      its(:valid?)  { should be_true }
-      its(:active?) { should be_true }
+      context "when linked path exists" do
+        context "when linked path is not writable" do
+          let(:real_path) { File.join(tmp_dir, 'real-path') }
+          let(:log_path) { File.join(tmp_dir, 'symlink-path') }
+          before do
+            FileUtils.mkdir_p(real_path)
+            FileUtils.chmod(0444, real_path)
+            File.symlink(real_path, log_path)
+          end
+          after do
+            FileUtils.rm_rf(real_path)
+            FileUtils.rm(log_path)
+          end
+
+          include_examples '#log_file_path: tmp path'
+        end
 
-      its([:push_api_key])   { should eq 'aaa-bbb-ccc' }
-      its([:active])         { should eq true }
-      its([:name])           { should eq 'App name' }
-      its([:debug])          { should eq true }
-      its([:ignore_actions]) { should eq ['action1', 'action2'] }
+        context "when linked path is writable" do
+          let(:real_path) { File.join(tmp_dir, 'real-path') }
+          let(:log_path) { File.join(tmp_dir, 'symlink-path') }
+          before do
+            FileUtils.mkdir_p(real_path)
+            File.symlink(real_path, log_path)
+          end
+          after do
+            FileUtils.rm_rf(real_path)
+            FileUtils.rm(log_path)
+          end
+
+          it "returns real path of log path" do
+            expect(subject).to eq(File.join(real_path, 'appsignal.log'))
+          end
+        end
+      end
     end
   end
-
-  context "when a nil root path is passed" do
-    let(:initial_config) { {} }
-    let(:config) { Appsignal::Config.new(nil, 'production', initial_config) }
-
-    its(:valid?)  { should be_false }
-    its(:active?) { should be_false }
-  end
 end