appsignal 2.8.0.alpha.1 → 2.8.0

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

@@ -1,6 +1,6 @@
 require "appsignal/cli"
 
-describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
+describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_input do
   include CLIHelpers
 
   class DiagnosticsReportEndpoint
@@ -27,6 +27,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
     let(:gem_path) { Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip }
     let(:received_report) { DiagnosticsReportEndpoint.received_report }
     let(:process_user) { Etc.getpwuid(Process.uid).name }
+    let(:process_group) { Etc.getgrgid(Process.gid).name }
     before(:context) { Appsignal.stop }
     before do
       # Clear previous reports
@@ -51,13 +52,22 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
     before :api_stub => true do
       stub_api_request config, "auth"
     end
-    before :report => true do
-      send_diagnostics_report
-      stub_diagnostics_report_request.to_rack(DiagnosticsReportEndpoint)
+    before(:send_report => :yes_cli_input) do
+      accept_prompt_to_send_diagnostics_report
+      capture_diagnatics_report_request
+    end
+    before(:send_report => :no_cli_input) { dont_accept_prompt_to_send_diagnostics_report }
+    before(:send_report => :yes_cli_option) do
+      options[:send_report] = true
+      capture_diagnatics_report_request
     end
-    before(:report => false) { dont_send_diagnostics_report }
+    before(:send_report => :no_cli_option) { options[:send_report] = false }
     after { Appsignal.config = nil }
 
+    def capture_diagnatics_report_request
+      stub_diagnostics_report_request.to_rack(DiagnosticsReportEndpoint)
+    end
+
     def run
       run_within_dir project_fixture_path
     end
@@ -82,11 +92,11 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
       )
     end
 
-    def send_diagnostics_report
+    def accept_prompt_to_send_diagnostics_report
       add_cli_input "y"
     end
 
-    def dont_send_diagnostics_report
+    def dont_accept_prompt_to_send_diagnostics_report
       add_cli_input "n"
     end
 
@@ -94,22 +104,28 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
       run
       expect(output).to include \
         "AppSignal diagnose",
-        "http://docs.appsignal.com/",
+        "https://docs.appsignal.com/",
         "support@appsignal.com"
     end
 
+    it "logs to the log file" do
+      run
+      log_contents = File.read(config.log_file_path)
+      expect(log_contents).to contains_log :info, "Starting AppSignal diagnose"
+    end
+
     describe "report" do
       context "when user wants to send report" do
         it "sends report" do
           run
           expect(output).to include "Diagnostics report",
-            "Send diagnostics report to AppSignal? (Y/n): ",
-            "Please email us at support@appsignal.com with the following\n  support token."
+            "Send diagnostics report to AppSignal? (Y/n): "
         end
 
         it "outputs the support token from the server" do
           run
           expect(output).to include "Your support token: my_support_token"
+          expect(output).to include "View this report:   https://appsignal.com/diagnose/my_support_token"
         end
 
         context "when server response is invalid" do
@@ -138,7 +154,25 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         end
       end
 
-      context "when user doesn't want to send report", :report => false do
+      context "when user uses the --send-report option", :send_report => :yes_cli_option do
+        it "sends the report without prompting" do
+          run
+          expect(output).to include "Diagnostics report",
+            "Confirmed sending report using --send-report option.",
+            "Transmitting diagnostics report"
+        end
+      end
+
+      context "when user uses the --no-send-report option", :send_report => :no_cli_option do
+        it "does not send the report" do
+          run
+          expect(output).to include "Diagnostics report",
+            "Not sending report. (Specified with the --no-send-report option.)",
+            "Not sending diagnostics information to AppSignal."
+        end
+      end
+
+      context "when user doesn't want to send report", :send_report => :no_cli_input do
         it "does not send report" do
           run
           expect(output).to include "Diagnostics report",
@@ -155,8 +189,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         expect(output).to include \
           "Gem version: #{Appsignal::VERSION}",
           "Agent version: #{Appsignal::Extension.agent_version}",
-          "Agent architecture: #{Appsignal::System.installed_agent_architecture}",
-          "Gem install path: #{gem_path}"
+          "Agent architecture: #{Appsignal::System.installed_agent_architecture}"
       end
 
       it "transmits version numbers in report" do
@@ -166,7 +199,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
             "package_version" => Appsignal::VERSION,
             "agent_version" => Appsignal::Extension.agent_version,
             "agent_architecture" => Appsignal::System.installed_agent_architecture,
-            "package_install_path" => gem_path,
             "extension_loaded" => true
           }
         )
@@ -205,14 +237,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
     end
 
     describe "agent diagnostics" do
+      let(:working_directory_stat) { File.stat("/tmp/appsignal") }
+
       it "starts the agent in diagnose mode and outputs the report" do
         run
-        expect(output).to include \
-          "Agent diagnostics",
-          "  Extension config: valid",
-          "  Agent config: valid",
-          "  Agent logger: started",
-          "  Agent lock path: writable"
+        working_directory_stat = File.stat("/tmp/appsignal")
+        expect_valid_agent_diagnostics_report(output, working_directory_stat)
       end
 
       it "adds the agent diagnostics to the report" do
@@ -223,8 +253,17 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
           },
           "agent" => {
             "boot" => { "started" => { "result" => true } },
+            "host" => {
+              "uid" => { "result" => Process.uid },
+              "gid" => { "result" => Process.gid }
+            },
             "config" => { "valid" => { "result" => true } },
             "logger" => { "started" => { "result" => true } },
+            "working_directory_stat" => {
+              "uid" => { "result" => working_directory_stat.uid },
+              "gid" => { "result" => working_directory_stat.gid },
+              "mode" => { "result" => working_directory_stat.mode }
+            },
             "lock_path" => { "created" => { "result" => true } }
           }
         )
@@ -239,13 +278,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         it "force starts the agent in diagnose mode and outputs a log" do
           run
           expect(output).to include("active: false")
-          expect(output).to include \
-            "Agent diagnostics",
-            "  Extension config: valid",
-            "  Agent started: started",
-            "  Agent config: valid",
-            "  Agent logger: started",
-            "  Agent lock path: writable"
+          expect_valid_agent_diagnostics_report(output, working_directory_stat)
         end
       end
 
@@ -323,11 +356,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         it "prints the tests, but shows a dash `-` for missed results" do
           expect(output).to include \
             "Agent diagnostics",
-            "  Extension config: invalid",
-            "  Agent started: -",
-            "  Agent config: -",
-            "  Agent logger: -",
-            "  Agent lock path: -"
+            "  Extension tests\n    Configuration: invalid",
+            "  Agent tests",
+            "    Started: -",
+            "    Configuration: -",
+            "    Logger: -",
+            "    Lock path: -"
         end
 
         it "adds the output to the report" do
@@ -356,8 +390,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         it "prints the error and output" do
           expect(output).to include \
             "Agent diagnostics",
-            "  Extension config: valid",
-            "  Agent started: not started\n    Error: some-error"
+            "  Extension tests\n    Configuration: valid",
+            "  Agent tests\n    Started: not started\n      Error: some-error"
         end
 
         it "adds the agent report to the diagnostics report" do
@@ -382,8 +416,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
           run
           expect(output).to include \
             "Agent diagnostics",
-            "  Extension config: valid",
-            "  Agent config: invalid\n    Output: some output"
+            "  Extension tests\n    Configuration: valid",
+            "    Configuration: invalid\n      Output: some output"
         end
       end
     end
@@ -531,31 +565,147 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
 
         it "outputs a warning that no config is loaded" do
           expect(output).to include \
-            "Environment: \n    Warning: No environment set, no config loaded!",
+            "Environment: \"\"\n",
+            "    Warning: No environment set, no config loaded!",
             "  appsignal diagnose --environment=production"
         end
 
         it "outputs config defaults" do
           expect(output).to include("Configuration")
-          Appsignal::Config::DEFAULT_CONFIG.each do |key, value|
-            expect(output).to include("#{key}: #{value}")
-          end
+          expect_config_to_be_printed(Appsignal::Config::DEFAULT_CONFIG)
+        end
+
+        it "transmits validation in report" do
+          default_config = hash_with_string_keys(Appsignal::Config::DEFAULT_CONFIG)
+          expect(received_report["config"]).to eq(
+            "options" => default_config.merge("env" => ""),
+            "sources" => {
+              "default" => default_config,
+              "system" => {},
+              "initial" => { "env" => "" },
+              "file" => {},
+              "env" => {}
+            }
+          )
         end
       end
 
       context "with configured environment" do
-        before { run }
+        describe "environment" do
+          it "outputs environment" do
+            run
+            expect(output).to include(%(Environment: "production"))
+          end
 
-        it "outputs environment" do
-          expect(output).to include("Environment: production")
+          context "when the source is a single source" do
+            before { run }
+
+            it "outputs the label source after the value" do
+              expect(output).to include(
+                %(Environment: "#{Appsignal.config.env}" (Loaded from: initial)\n)
+              )
+            end
+          end
+
+          context "when the source is multiple sources" do
+            let(:options) { { :environment => "development" } }
+            before do
+              ENV["APPSIGNAL_APP_ENV"] = "production"
+              config.instance_variable_set(:@env, ENV["APPSIGNAL_APP_ENV"])
+              stub_api_request(config, "auth").to_return(:status => 200)
+              capture_diagnatics_report_request
+              run
+            end
+
+            it "outputs a list of sources with their values" do
+              expect(output).to include(
+                %(  Environment: "production"\n) +
+                %(    Sources:\n) +
+                %(      initial: "development"\n) +
+                %(      env:     "production"\n)
+              )
+            end
+          end
         end
 
         it "outputs configuration" do
+          run
           expect(output).to include("Configuration")
-          Appsignal.config.config_hash.each do |key, value|
-            expect(output).to include("#{key}: #{value}")
+          expect_config_to_be_printed(Appsignal.config.config_hash)
+        end
+
+        describe "option sources" do
+          context "when the source is a single source" do
+            before { run }
+
+            it "outputs the label source after the value" do
+              expect(output).to include(
+                %(push_api_key: "#{Appsignal.config[:push_api_key]}" (Loaded from: file)\n)
+              )
+            end
+
+            context "when the source is only default" do
+              it "does not print a source" do
+                expect(output).to include("debug: #{Appsignal.config[:debug]}\n")
+              end
+            end
+          end
+
+          context "when the source is multiple sources" do
+            before do
+              ENV["APPSIGNAL_APP_NAME"] = "MyApp"
+              config[:name] = ENV["APPSIGNAL_APP_NAME"]
+              stub_api_request(config, "auth").to_return(:status => 200)
+              capture_diagnatics_report_request
+              run
+            end
+
+            if DependencyHelper.rails_present?
+              it "outputs a list of sources with their values" do
+                expect(output).to include(
+                  %(  name: "MyApp"\n) +
+                  %(    Sources:\n) +
+                  %(      initial: "MyApp"\n) +
+                  %(      file:    "TestApp"\n) +
+                  %(      env:     "MyApp"\n)
+                )
+              end
+            else
+              it "outputs a list of sources with their values" do
+                expect(output).to include(
+                  %(  name: "MyApp"\n) +
+                  %(    Sources:\n) +
+                  %(      file: "TestApp"\n) +
+                  %(      env:  "MyApp"\n)
+                )
+              end
+            end
           end
         end
+
+        it "transmits config in report" do
+          run
+          additional_initial_config = {}
+          if DependencyHelper.rails_present?
+            additional_initial_config = {
+              :name => "MyApp",
+              :log_path => File.join(Rails.root, "log")
+            }
+          end
+          final_config = { "env" => "production" }
+            .merge(additional_initial_config)
+            .merge(config.config_hash)
+          expect(received_report["config"]).to match(
+            "options" => hash_with_string_keys(final_config),
+            "sources" => {
+              "default" => hash_with_string_keys(Appsignal::Config::DEFAULT_CONFIG),
+              "system" => {},
+              "initial" => hash_with_string_keys(config.initial_config.merge(additional_initial_config)),
+              "file" => hash_with_string_keys(config.file_config),
+              "env" => {}
+            }
+          )
+        end
       end
 
       context "with unconfigured environment" do
@@ -563,14 +713,42 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         before { run_within_dir tmp_dir }
 
         it "outputs environment" do
-          expect(output).to include("Environment: foobar")
+          expect(output).to include(%(Environment: "foobar"))
         end
 
         it "outputs config defaults" do
           expect(output).to include("Configuration")
-          Appsignal::Config::DEFAULT_CONFIG.each do |key, value|
-            expect(output).to include("#{key}: #{value}")
-          end
+          expect_config_to_be_printed(Appsignal::Config::DEFAULT_CONFIG)
+        end
+
+        it "transmits config in report" do
+          expect(received_report["config"]).to match(
+            "options" => hash_with_string_keys(config.config_hash).merge("env" => "foobar"),
+            "sources" => {
+              "default" => hash_with_string_keys(Appsignal::Config::DEFAULT_CONFIG),
+              "system" => {},
+              "initial" => hash_with_string_keys(config.initial_config),
+              "file" => hash_with_string_keys(config.file_config),
+              "env" => {}
+            }
+          )
+        end
+      end
+
+      def expect_config_to_be_printed(config)
+        nil_options = config.select { |_, v| v.nil? }
+        nil_options.each_key do |key|
+          expect(output).to include(%(#{key}: nil))
+        end
+        string_options = config.select { |_, v| v.is_a?(String) }
+        string_options.each do |key, value|
+          expect(output).to include(%(#{key}: "#{value}"))
+        end
+        other_options = config.select do |k, _|
+          !string_options.key?(k) && !nil_options.key?(k)
+        end
+        other_options.each do |key, value|
+          expect(output).to include(%(#{key}: #{value}))
         end
       end
     end
@@ -639,6 +817,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
     end
 
     describe "paths" do
+      let(:config) { Appsignal::Config.new(root_path, "production") }
+      let(:root_path) { tmp_dir }
       let(:system_tmp_dir) { Appsignal::Config.system_tmp_dir }
       before do
         FileUtils.mkdir_p(root_path)
@@ -647,82 +827,220 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
       after { FileUtils.rm_rf([root_path, system_tmp_dir]) }
 
       describe "report" do
-        let(:root_path) { tmp_dir }
-
         it "adds paths to the report" do
-          run
-          expect(received_report["paths"].keys)
-            .to match_array(%w[root_path working_dir log_dir_path log_file_path])
+          run_within_dir root_path
+          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
+            ]
+          )
         end
-      end
 
-      context "when a directory is not configured" do
-        let(:root_path) { File.join(tmp_dir, "writable_path") }
-        let(:config) { Appsignal::Config.new(root_path, "production", :log_file => nil) }
-        before do
-          FileUtils.mkdir_p(File.join(root_path, "log"), :mode => 0o555)
-          FileUtils.chmod(0o555, system_tmp_dir)
-          run_within_dir root_path
+        describe "working_dir" do
+          before { run_within_dir root_path }
+
+          it "outputs current path" do
+            expect(output).to include %(Current working directory\n    Path: "#{tmp_dir}")
+          end
+
+          it "transmits path data in report" do
+            expect(received_report["paths"]["working_dir"]).to match(
+              "path" => tmp_dir,
+              "exists" => true,
+              "type" => "directory",
+              "mode" => kind_of(String),
+              "writable" => boolean,
+              "ownership" => {
+                "uid" => kind_of(Integer),
+                "user" => kind_of(String),
+                "gid" => kind_of(Integer),
+                "group" => kind_of(String)
+              }
+            )
+          end
         end
 
-        it "outputs unconfigured directory" do
-          expect(output).to include %(log_file_path: ""\n    Configured?: false)
+        describe "root_path" do
+          before { run_within_dir root_path }
+
+          it "outputs root path" do
+            expect(output).to include %(Root path\n    Path: "#{root_path}")
+          end
+
+          it "transmits path data in report" do
+            expect(received_report["paths"]["root_path"]).to match(
+              "path" => root_path,
+              "exists" => true,
+              "type" => "directory",
+              "mode" => kind_of(String),
+              "writable" => boolean,
+              "ownership" => {
+                "uid" => kind_of(Integer),
+                "user" => kind_of(String),
+                "gid" => kind_of(Integer),
+                "group" => kind_of(String)
+              }
+            )
+          end
         end
 
-        it "transmits path data in report" do
-          expect(received_report["paths"]["log_file_path"]).to eq(
-            "path" => nil,
-            "configured" => false,
-            "exists" => false,
-            "writable" => false
-          )
+        describe "package_install_path" do
+          before { run_within_dir root_path }
+
+          it "outputs gem install path" do
+            expect(output).to match %(AppSignal gem path\n    Path: "#{gem_path}")
+          end
+
+          it "transmits path data in report" do
+            expect(received_report["paths"]["package_install_path"]).to match(
+              "path" => gem_path,
+              "exists" => true,
+              "type" => "directory",
+              "mode" => kind_of(String),
+              "writable" => boolean,
+              "ownership" => {
+                "uid" => kind_of(Integer),
+                "user" => kind_of(String),
+                "gid" => kind_of(Integer),
+                "group" => kind_of(String)
+              }
+            )
+          end
+        end
+
+        describe "log_dir_path" do
+          before { run_within_dir root_path }
+
+          it "outputs log directory path" do
+            expect(output).to match %(Log directory\n    Path: "#{system_tmp_dir}")
+          end
+
+          it "transmits path data in report" do
+            expect(received_report["paths"]["log_dir_path"]).to match(
+              "path" => system_tmp_dir,
+              "exists" => true,
+              "type" => "directory",
+              "mode" => kind_of(String),
+              "writable" => boolean,
+              "ownership" => {
+                "uid" => kind_of(Integer),
+                "user" => kind_of(String),
+                "gid" => kind_of(Integer),
+                "group" => kind_of(String)
+              }
+            )
+          end
         end
       end
 
       context "when a directory does not exist" do
         let(:root_path) { tmp_dir }
         let(:execution_path) { File.join(tmp_dir, "not_existing_dir") }
-        let(:config) { Appsignal::Config.new(execution_path, "production") }
+        let(:config) do
+          silence(:allowed => ["Push api key not set after loading config"]) do
+            Appsignal::Config.new(execution_path, "production")
+          end
+        end
         before do
           allow(Dir).to receive(:pwd).and_return(execution_path)
           run_within_dir tmp_dir
         end
 
         it "outputs not existing path" do
-          expect(output).to include %(root_path: "#{execution_path}"\n    Exists?: false)
+          expect(output).to include %(Root path\n    Path: "#{execution_path}"\n    Exists?: false)
         end
 
         it "transmits path data in report" do
           expect(received_report["paths"]["root_path"]).to eq(
             "path" => execution_path,
-            "configured" => true,
-            "exists" => false,
-            "writable" => false
+            "exists" => false
           )
         end
       end
 
-      describe "ownership" do
-        let(:config) { Appsignal::Config.new(root_path, "production") }
+      context "when not writable" do
+        let(:root_path) { File.join(tmp_dir, "not_writable_path") }
+        before do
+          FileUtils.chmod(0o555, root_path)
+          run_within_dir root_path
+        end
+
+        it "outputs not writable root path" do
+          expect(output).to include %(Root path\n    Path: "#{root_path}"\n    Writable?: false)
+        end
+
+        it "transmits path data in report" do
+          expect(received_report["paths"]["root_path"]).to eq(
+            "path" => root_path,
+            "exists" => true,
+            "type" => "directory",
+            "mode" => "40555",
+            "writable" => false,
+            "ownership" => {
+              "uid" => Process.uid,
+              "user" => process_user,
+              "gid" => Process.gid,
+              "group" => process_group
+            }
+          )
+        end
+      end
+
+      context "when writable" do
+        let(:root_path) { File.join(tmp_dir, "writable_path") }
+        before do
+          FileUtils.chmod(0o755, root_path)
+          run_within_dir root_path
+        end
+
+        it "outputs writable root path" do
+          expect(output).to include %(Root path\n    Path: "#{root_path}"\n    Writable?: true)
+        end
 
+        it "transmits path data in report" do
+          expect(received_report["paths"]["root_path"]).to eq(
+            "path" => root_path,
+            "exists" => true,
+            "type" => "directory",
+            "mode" => "40755",
+            "writable" => true,
+            "ownership" => {
+              "uid" => Process.uid,
+              "user" => process_user,
+              "gid" => Process.gid,
+              "group" => process_group
+            }
+          )
+        end
+      end
+
+      describe "ownership" do
         context "when a directory is owned by the current user" do
           let(:root_path) { File.join(tmp_dir, "owned_path") }
           before { run_within_dir root_path }
 
           it "outputs ownership" do
             expect(output).to include \
-              %(root_path: "#{root_path}"\n    Writable?: true\n    ) \
+              %(Root path\n    Path: "#{root_path}"\n    Writable?: true\n    ) \
                 "Ownership?: true (file: #{process_user}:#{Process.uid}, "\
                 "process: #{process_user}:#{Process.uid})"
           end
 
           it "transmits path data in report" do
+            mode = ENV["RUNNING_IN_CI"] ? "40775" : "40755"
             expect(received_report["paths"]["root_path"]).to eq(
               "path" => root_path,
-              "configured" => true,
               "exists" => true,
+              "type" => "directory",
+              "mode" => mode,
               "writable" => true,
-              "ownership" => { "uid" => Process.uid, "user" => process_user }
+              "ownership" => {
+                "uid" => Process.uid,
+                "user" => process_user,
+                "gid" => Process.gid,
+                "group" => process_group
+              }
             )
           end
         end
@@ -738,228 +1056,80 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
 
           it "outputs no ownership" do
             expect(output).to include \
-              %(root_path: "#{root_path}"\n    Writable?: true\n    ) \
+              %(Root path\n    Path: "#{root_path}"\n    Writable?: true\n    ) \
                 "Ownership?: false (file: root:0, process: #{process_user}:#{Process.uid})"
           end
         end
       end
-
-      describe "working_dir" do
-        let(:root_path) { tmp_dir }
-        let(:config) { Appsignal::Config.new(root_path, "production") }
-        before { run_within_dir root_path }
-
-        it "outputs current path" do
-          expect(output).to include %(working_dir: "#{tmp_dir}"\n    Writable?: true)
-        end
-
-        it "transmits path data in report" do
-          expect(received_report["paths"]["working_dir"]).to eq(
-            "path" => tmp_dir,
-            "configured" => true,
-            "exists" => true,
-            "writable" => true,
-            "ownership" => { "uid" => Process.uid, "user" => process_user }
-          )
-        end
-      end
-
-      describe "root_path" do
-        let(:system_tmp_log_file) { File.join(system_tmp_dir, "appsignal.log") }
-        let(:config) { Appsignal::Config.new(root_path, "production") }
-
-        context "when not writable" do
-          let(:root_path) { File.join(tmp_dir, "not_writable_path") }
-          before do
-            FileUtils.chmod(0o555, root_path)
-            run_within_dir root_path
-          end
-
-          it "outputs not writable root path" do
-            expect(output).to include %(root_path: "#{root_path}"\n    Writable?: false)
-          end
-
-          it "log files fall back on system tmp directory" do
-            expect(output).to include \
-              %(log_dir_path: "#{system_tmp_dir}"\n    Writable?: true),
-              %(log_file_path: "#{system_tmp_log_file}"\n    Exists?: false)
-          end
-
-          it "transmits path data in report" do
-            expect(received_report["paths"]["root_path"]).to eq(
-              "path" => root_path,
-              "configured" => true,
-              "exists" => true,
-              "writable" => false,
-              "ownership" => { "uid" => Process.uid, "user" => process_user }
-            )
-          end
-        end
-
-        context "when writable" do
-          let(:root_path) { File.join(tmp_dir, "writable_path") }
-
-          context "without log dir" do
-            before do
-              FileUtils.chmod(0o777, root_path)
-              run_within_dir root_path
-            end
-
-            it "outputs writable root path" do
-              expect(output).to include %(root_path: "#{root_path}"\n    Writable?: true)
-            end
-
-            it "log files fall back on system tmp directory" do
-              expect(output).to include \
-                %(log_dir_path: "#{system_tmp_dir}"\n    Writable?: true),
-                %(log_file_path: "#{system_tmp_log_file}"\n    Exists?: false)
-            end
-
-            it "transmits path data in report" do
-              expect(received_report["paths"]["root_path"]).to eq(
-                "path" => root_path,
-                "configured" => true,
-                "exists" => true,
-                "writable" => true,
-                "ownership" => { "uid" => Process.uid, "user" => process_user }
-              )
-            end
-          end
-
-          context "with log dir" do
-            let(:log_dir) { File.join(root_path, "log") }
-            let(:log_file) { File.join(log_dir, "appsignal.log") }
-            before { FileUtils.mkdir_p(log_dir) }
-
-            context "when not writable" do
-              before do
-                FileUtils.chmod(0o444, log_dir)
-                run_within_dir root_path
-              end
-
-              it "log files fall back on system tmp directory" do
-                expect(output).to include \
-                  %(log_dir_path: "#{system_tmp_dir}"\n    Writable?: true),
-                  %(log_file_path: "#{system_tmp_log_file}"\n    Exists?: false)
-              end
-
-              it "transmits path data in report" do
-                expect(received_report["paths"]["log_dir_path"]).to be_kind_of(Hash)
-                expect(received_report["paths"]["log_file_path"]).to be_kind_of(Hash)
-              end
-            end
-
-            context "when writable" do
-              context "without log file" do
-                before { run_within_dir root_path }
-
-                it "outputs writable but without log file" do
-                  expect(output).to include \
-                    %(root_path: "#{root_path}"\n    Writable?: true),
-                    %(log_dir_path: "#{log_dir}"\n    Writable?: true),
-                    %(log_file_path: "#{log_file}"\n    Exists?: false)
-                end
-
-                it "transmits path data in report" do
-                  expect(received_report["paths"]["log_dir_path"]).to be_kind_of(Hash)
-                  expect(received_report["paths"]["log_file_path"]).to be_kind_of(Hash)
-                end
-              end
-
-              context "with log file" do
-                context "when writable" do
-                  before do
-                    FileUtils.touch(log_file)
-                    run_within_dir root_path
-                  end
-
-                  it "lists log file as writable" do
-                    expect(output).to include %(log_file_path: "#{log_file}"\n    Writable?: true)
-                  end
-
-                  it "transmits path data in report" do
-                    expect(received_report["paths"]["log_dir_path"]).to be_kind_of(Hash)
-                    expect(received_report["paths"]["log_file_path"]).to be_kind_of(Hash)
-                  end
-                end
-
-                context "when not writable" do
-                  before do
-                    FileUtils.touch(log_file)
-                    FileUtils.chmod(0o444, log_file)
-                    run_within_dir root_path
-                  end
-
-                  it "lists log file as not writable" do
-                    expect(output).to include %(log_file_path: "#{log_file}"\n    Writable?: false)
-                  end
-
-                  it "transmits path data in report" do
-                    expect(received_report["paths"]["log_dir_path"]).to be_kind_of(Hash)
-                    expect(received_report["paths"]["log_file_path"]).to be_kind_of(Hash)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
     end
 
-    describe "logs" do
-      shared_examples "ext log file" do |log_file|
-        let(:ext_path) { File.join(gem_path, "ext") }
-        let(:log_path) { File.join(ext_path, log_file) }
-        before do
-          FileUtils.mkdir_p ext_path
-          allow(cli).to receive(:gem_path).and_return(gem_path)
-        end
-        after { FileUtils.rm_rf ext_path }
+    describe "files" do
+      shared_examples "diagnose file" do |shared_example_options|
+        let(:parent_directory) { File.join(tmp_dir, "diagnose_files") }
+        let(:file_path) { File.join(parent_directory, filename) }
+        before { FileUtils.mkdir_p File.dirname(file_path) }
+        after { FileUtils.rm_rf parent_directory }
 
         context "when file exists" do
-          let(:gem_path) { File.join(tmp_dir, "gem") }
-          let(:log_content) do
-            [
-              "log line 1",
-              "log line 2"
-            ]
+          let(:contents) do
+            [].tap do |lines|
+              (1..12).each do |i|
+                lines << "log line #{i}"
+              end
+            end
           end
           before do
-            File.open log_path, "a" do |f|
-              log_content.each do |line|
+            File.open file_path, "a" do |f|
+              contents.each do |line|
                 f.puts line
               end
             end
             run
           end
 
-          it "outputs install.log" do
-            expect(output).to include(%(Path: "#{log_path}"))
-            expect(output).to include(*log_content)
+          it "outputs file location and content" do
+            expect(output).to include(
+              %(Path: "#{file_path}"),
+              "Contents (last 10 lines):"
+            )
+            expect(output).to include(*contents.last(10).join("\n"))
+            expect(output).to_not include(*contents.first(2).join("\n"))
           end
 
-          it "transmits log data in report" do
-            expect(received_report["logs"][File.join("ext", log_file)]).to eq(
-              "path" => log_path,
+          it "transmits file data in report" do
+            expect(received_report["paths"][filename]).to match(
+              "path" => file_path,
               "exists" => true,
-              "content" => log_content
+              "type" => "file",
+              "mode" => kind_of(String),
+              "writable" => boolean,
+              "ownership" => {
+                "uid" => kind_of(Integer),
+                "user" => kind_of(String),
+                "gid" => kind_of(Integer),
+                "group" => kind_of(String)
+              },
+              "content" => contents
             )
           end
-
-          after { FileUtils.rm_rf(gem_path) }
         end
 
         context "when file does not exist" do
-          let(:gem_path) { File.join(tmp_dir, "gem_without_log_files") }
-          before { run }
+          before do
+            if shared_example_options && shared_example_options[:stub_not_exists]
+              allow(File).to receive(:exist?).and_call_original
+              expect(File).to receive(:exist?).with(file_path).and_return(false)
+            end
+            run
+          end
 
-          it "outputs install.log" do
-            expect(output).to include %(Path: "#{log_path}"\n    File not found.)
+          it "outputs file does not exists" do
+            expect(output).to include %(Path: "#{file_path}"\n    Exists?: false)
           end
 
-          it "transmits log data in report" do
-            expect(received_report["logs"][File.join("ext", log_file)]).to eq(
-              "path" => log_path,
+          it "transmits file data in report" do
+            expect(received_report["paths"][filename]).to eq(
+              "path" => file_path,
               "exists" => false
             )
           end
@@ -967,7 +1137,15 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
       end
 
       describe "install.log" do
-        it_behaves_like "ext log file", "install.log"
+        it_behaves_like "diagnose file" do
+          let(:filename) { File.join("ext", "install.log") }
+          before do
+            expect(Bundler::CLI::Common).to receive(:select_spec)
+              .with("appsignal")
+              .at_least(:once)
+              .and_return(double(:full_gem_path => parent_directory))
+          end
+        end
 
         it "outputs header" do
           run
@@ -976,13 +1154,55 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
       end
 
       describe "mkmf.log" do
-        it_behaves_like "ext log file", "mkmf.log"
+        it_behaves_like "diagnose file" do
+          let(:filename) { File.join("ext", "mkmf.log") }
+          before do
+            expect(Bundler::CLI::Common).to receive(:select_spec)
+              .with("appsignal")
+              .at_least(:once)
+              .and_return(double(:full_gem_path => parent_directory))
+          end
+        end
 
         it "outputs header" do
           run
           expect(output).to include("Makefile install log")
         end
       end
+
+      describe "appsignal.log" do
+        it_behaves_like "diagnose file", :stub_not_exists => true do
+          let(:filename) { "appsignal.log" }
+          before do
+            ENV["APPSIGNAL_LOG"] = "stdout"
+            expect_any_instance_of(Appsignal::Config).to receive(:log_file_path).at_least(:once).and_return(file_path)
+          end
+        end
+
+        it "outputs header" do
+          run
+          expect(output).to include("AppSignal log")
+        end
+      end
     end
   end
+
+  def expect_valid_agent_diagnostics_report(output, working_directory_stat)
+    expect(output).to include \
+      "Agent diagnostics",
+      "  Extension tests\n    Configuration: valid",
+      "    Started: started",
+      "    Process user id: #{Process.uid}",
+      "    Process user group id: #{Process.gid}\n" \
+        "    Configuration: valid",
+      "    Logger: started",
+      "    Working directory user id: #{working_directory_stat.uid}",
+      "    Working directory user group id: #{working_directory_stat.gid}",
+      "    Working directory permissions: #{working_directory_stat.mode}",
+      "    Lock path: writable"
+  end
+
+  def hash_with_string_keys(hash)
+    Hash[hash.map { |key, value| [key.to_s, value] }]
+  end
 end