appsignal 2.1.2 → 2.2.0.beta.1

data/lib/appsignal/utils/params_sanitizer.rb

@@ -1,5 +1,6 @@
 module Appsignal
   module Utils
+    # @api private
     class ParamsSanitizer
       FILTERED = "[FILTERED]".freeze
 
@@ -16,7 +17,7 @@ module Appsignal
             sanitize_hash(value, options)
           when Array
             sanitize_array(value, options)
-          when TrueClass, FalseClass, NilClass, Fixnum, String, Symbol, Float
+          when TrueClass, FalseClass, NilClass, Integer, String, Symbol, Float
             unmodified(value)
           else
             inspected(value)

data/lib/appsignal/utils/query_params_sanitizer.rb

@@ -1,5 +1,6 @@
 module Appsignal
   module Utils
+    # @api private
     class QueryParamsSanitizer
       REPLACEMENT_KEY = "?".freeze
 

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require "yaml"
 
 module Appsignal
-  VERSION = "2.1.2"
+  VERSION = "2.2.0.beta.1".freeze
 end

data/resources/appsignal.yml.erb

@@ -10,7 +10,7 @@ default: &defaults
   # ignore_actions:
   #   - ApplicationController#isup
 
-  # See http://docs.appsignal.com/gem-settings/configuration.html for
+  # See http://docs.appsignal.com/ruby/configuration/options.html for
   # all configuration options.
 
 # Configuration per environment, leave out an environment or set active

data/spec/lib/appsignal/auth_check_spec.rb

@@ -1,37 +1,79 @@
 describe Appsignal::AuthCheck do
   let(:config) { project_fixture_config }
   let(:auth_check) { Appsignal::AuthCheck.new(config) }
+  let(:auth_url) do
+    query = {
+      :api_key => config[:push_api_key],
+      :environment => config.env,
+      :gem_version => Appsignal::VERSION,
+      :hostname => config[:hostname],
+      :name => config[:name]
+    }.map { |k, v| "#{k}=#{v}" }.join("&")
 
-  describe "#perform_with_result" do
-    it "should give success message" do
-      expect(auth_check).to receive(:perform).and_return("200")
-      expect(auth_check.perform_with_result).to eq ["200", "AppSignal has confirmed authorization!"]
-    end
+    URI(config[:endpoint]).tap do |uri|
+      uri.path = "/1/auth"
+      uri.query = query
+    end.to_s
+  end
+  let(:stubbed_request) do
+    WebMock.stub_request(:post, auth_url).with(:body => "{}")
+  end
+
+  describe "#perform" do
+    subject { auth_check.perform }
+
+    context "when performing a request against the push api" do
+      before { stubbed_request.to_return(:status => 200) }
 
-    it "should give 401 message" do
-      expect(auth_check).to receive(:perform).and_return("401")
-      expect(auth_check.perform_with_result).to eq ["401", "API key not valid with AppSignal..."]
+      it "returns status code" do
+        is_expected.to eq("200")
+      end
     end
 
-    it "should give an error message" do
-      expect(auth_check).to receive(:perform).and_return("402")
-      expect(auth_check.perform_with_result).to eq ["402", "Could not confirm authorization: 402"]
+    context "when encountering an exception" do
+      before { stubbed_request.to_timeout }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(Net::OpenTimeout)
+      end
     end
   end
 
-  context "transmitting" do
-    before do
-      @transmitter = double
-      expect(Appsignal::Transmitter).to receive(:new).with(
-        "auth",
-        kind_of(Appsignal::Config)
-      ).and_return(@transmitter)
+  describe "#perform_with_result" do
+    subject { auth_check.perform_with_result }
+
+    context "when successful response" do
+      before { stubbed_request.to_return(:status => 200) }
+
+      it "returns success tuple" do
+        is_expected.to eq ["200", "AppSignal has confirmed authorization!"]
+      end
+    end
+
+    context "when unauthorized response" do
+      before { stubbed_request.to_return(:status => 401) }
+
+      it "returns unauthorirzed tuple" do
+        is_expected.to eq ["401", "API key not valid with AppSignal..."]
+      end
     end
 
-    describe "#perform" do
-      it "should not transmit any extra data" do
-        expect(@transmitter).to receive(:transmit).with({}).and_return({})
-        auth_check.perform
+    context "when unrecognized response" do
+      before { stubbed_request.to_return(:status => 500) }
+
+      it "returns an error tuple" do
+        is_expected.to eq ["500", "Could not confirm authorization: 500"]
+      end
+    end
+
+    context "when encountering an exception" do
+      before { stubbed_request.to_timeout }
+
+      it "returns an error tuple" do
+        is_expected.to eq [
+          nil,
+          "Something went wrong while trying to authenticate with AppSignal: execution expired"
+        ]
       end
     end
   end

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

@@ -1,21 +1,53 @@
 require "appsignal/cli"
 
-describe Appsignal::CLI::Diagnose, :api_stub => true do
+describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
+  include CLIHelpers
+
+  class DiagnosticsReportEndpoint
+    class << self
+      attr_reader :received_report
+
+      def clear_report!
+        @received_report = nil
+      end
+
+      def call(env)
+        @received_report = JSON.parse(env["rack.input"].read)["diagnose"]
+        [200, {}, [JSON.generate(:token => "my_support_token")]]
+      end
+    end
+  end
+
   describe ".run" do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
     let(:config) { project_fixture_config }
     let(:cli) { described_class }
     let(:options) { { :environment => config.env } }
+    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 }
     before(:context) { Appsignal.stop }
     before do
+      DiagnosticsReportEndpoint.clear_report!
       if DependencyHelper.rails_present?
         allow(Rails).to receive(:root).and_return(Pathname.new(config.root_path))
       end
     end
+    around do |example|
+      original_stdin = $stdin
+      $stdin = StringIO.new
+      example.run
+      $stdin = original_stdin
+    end
     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)
+    end
+    before(:report => false) { dont_send_diagnostics_report }
     after { Appsignal.config = nil }
 
     def run
@@ -23,11 +55,33 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
     end
 
     def run_within_dir(chdir)
+      prepare_input
       Dir.chdir chdir do
         capture_stdout(out_stream) { cli.run(options) }
       end
     end
 
+    def stub_diagnostics_report_request
+      stub_request(:post, "https://appsignal.com/diag").with(
+        :query => {
+          :api_key => config[:push_api_key],
+          :environment => config.env,
+          :gem_version => Appsignal::VERSION,
+          :hostname => config[:hostname],
+          :name => config[:name]
+        },
+        :headers => { "Content-Type" => "application/json; charset=UTF-8" }
+      )
+    end
+
+    def send_diagnostics_report
+      set_input "y"
+    end
+
+    def dont_send_diagnostics_report
+      set_input "n"
+    end
+
     it "outputs header and support text" do
       run
       expect(output).to include \
@@ -36,31 +90,87 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         "support@appsignal.com"
     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): ",
+            "Your diagnostics report has been sent to AppSignal."
+        end
+
+        it "outputs the support token from the server" do
+          run
+          expect(output).to include "Your support token: my_support_token"
+        end
+
+        context "when server response is invalid" do
+          before do
+            stub_diagnostics_report_request
+              .to_return(:status => 200, :body => %({ foo: "Invalid json", a: }))
+            run
+          end
+
+          it "outputs the server response in full" do
+            expect(output).to include "Error: Couldn't decode server response.",
+              %({ foo: "Invalid json", a: })
+          end
+        end
+
+        context "when server returns an error" do
+          before do
+            stub_diagnostics_report_request
+              .to_return(:status => 500, :body => "report: server error")
+            run
+          end
+
+          it "outputs the server response in full" do
+            expect(output).to include "report: server error"
+          end
+        end
+      end
+
+      context "when user doesn't want to send report", :report => false do
+        it "does not send report" do
+          run
+          expect(output).to include "Diagnostics report",
+            "Send diagnostics report to AppSignal? (Y/n): ",
+            "Not sending diagnostics information to AppSignal."
+        end
+      end
+    end
+
     describe "agent information" do
+      before { run }
+
       it "outputs version numbers" do
-        run
-        gem_path = Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
         expect(output).to include \
           "Gem version: #{Appsignal::VERSION}",
           "Agent version: #{Appsignal::Extension.agent_version}",
           "Gem install path: #{gem_path}"
       end
 
+      it "transmits version numbers in report" do
+        expect(received_report).to include(
+          "library" => {
+            "language" => "ruby",
+            "package_version" => Appsignal::VERSION,
+            "agent_version" => Appsignal::Extension.agent_version,
+            "package_install_path" => gem_path,
+            "extension_loaded" => true
+          }
+        )
+      end
+
       context "with extension" do
+        before { run }
+
         it "outputs extension is loaded" do
-          run
-          expect(output).to include "Extension loaded: yes"
+          expect(output).to include "Extension loaded: true"
         end
 
-        it "starts the agent in diagnose mode and outputs a log" do
-          run
-          expect(output).to include \
-            "Agent diagnostics:",
-            "Running agent in diagnose mode",
-            "Valid config present",
-            "Logger initialized successfully",
-            "Lock path is writable",
-            "Agent diagnose finished"
+        it "transmits extension_loaded: true in report" do
+          expect(received_report["library"]["extension_loaded"]).to eq(true)
         end
       end
 
@@ -75,26 +185,217 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         after { Appsignal.extension_loaded = true }
 
         it "outputs extension is not loaded" do
-          expect(output).to include "Extension loaded: no"
+          expect(output).to include "Extension loaded: false"
+        end
+
+        it "transmits extension_loaded: false in report" do
+          expect(received_report["library"]["extension_loaded"]).to eq(false)
+        end
+      end
+    end
+
+    describe "agent diagnostics" do
+      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"
+      end
+
+      it "adds the agent diagnostics to the report" do
+        run
+        expect(received_report["agent"]).to eq(
+          "extension" => {
+            "config" => { "valid" => { "result" => true } }
+          },
+          "agent" => {
+            "boot" => { "started" => { "result" => true } },
+            "config" => { "valid" => { "result" => true } },
+            "logger" => { "started" => { "result" => true } },
+            "lock_path" => { "created" => { "result" => true } }
+          }
+        )
+      end
+
+      context "when user config has active: false" do
+        before do
+          # ENV is leading so easiest to set in test to force user config with active: false
+          ENV["APPSIGNAL_ACTIVE"] = "false"
+        end
+
+        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"
+        end
+      end
+
+      context "when the extention returns invalid JSON" do
+        before do
+          expect(Appsignal::Extension).to receive(:diagnose).and_return("invalid agent\njson")
+          run
+        end
+
+        it "prints a JSON parse error and prints the returned value" do
+          expect(output).to include \
+            "Agent diagnostics",
+            "  Error while parsing agent diagnostics report:",
+            "    Output: invalid agent\njson"
+          expect(output).to match(/Error: \d+: unexpected token at 'invalid agent\njson'/)
+        end
+
+        it "adds the output to the report" do
+          expect(received_report["agent"]["error"])
+            .to match(/\d+: unexpected token at 'invalid agent\njson'/)
+          expect(received_report["agent"]["output"]).to eq(["invalid agent", "json"])
+        end
+      end
+
+      context "when the report contains an error" do
+        let(:agent_report) do
+          { "error" => "fatal error" }
+        end
+        before do
+          expect(Appsignal::Extension).to receive(:diagnose).and_return(JSON.generate(agent_report))
+          run
+        end
+
+        it "prints an error for the entire report" do
+          expect(output).to include "Agent diagnostics\n  Error: fatal error"
+        end
+
+        it "adds the error to the report" do
+          expect(received_report["agent"]).to eq(agent_report)
+        end
+      end
+
+      context "when the report is incomplete (agent failed to start)" do
+        let(:agent_report) do
+          {
+            "extension" => {
+              "config" => { "valid" => { "result" => false } }
+            }
+            # missing agent section
+          }
+        end
+        before do
+          expect(Appsignal::Extension).to receive(:diagnose).and_return(JSON.generate(agent_report))
+          run
+        end
+
+        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: -"
+        end
+
+        it "adds the output to the report" do
+          expect(received_report["agent"]).to eq(agent_report)
+        end
+      end
+
+      context "when a test contains an error" do
+        let(:agent_report) do
+          {
+            "extension" => {
+              "config" => { "valid" => { "result" => true } }
+            },
+            "agent" => {
+              "boot" => {
+                "started" => { "result" => false, "error" => "some-error" }
+              }
+            }
+          }
+        end
+        before do
+          expect(Appsignal::Extension).to receive(:diagnose).and_return(JSON.generate(agent_report))
+          run
+        end
+
+        it "prints the error and output" do
+          expect(output).to include \
+            "Agent diagnostics",
+            "  Extension config: valid",
+            "  Agent started: not started\n    Error: some-error"
+        end
+
+        it "adds the agent report to the diagnostics report" do
+          expect(received_report["agent"]).to eq(agent_report)
+        end
+      end
+
+      context "when a test contains command output" do
+        let(:agent_report) do
+          {
+            "extension" => {
+              "config" => { "valid" => { "result" => true } }
+            },
+            "agent" => {
+              "config" => { "valid" => { "result" => false, "output" => "some output" } }
+            }
+          }
+        end
+
+        it "prints the command output" do
+          expect(Appsignal::Extension).to receive(:diagnose).and_return(JSON.generate(agent_report))
+          run
+          expect(output).to include \
+            "Agent diagnostics",
+            "  Extension config: valid",
+            "  Agent config: invalid\n    Output: some output"
         end
       end
     end
 
     describe "host information" do
+      let(:rbconfig) { RbConfig::CONFIG }
+      let(:language_version) { "#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}" }
+
       it "outputs host information" do
         run
         expect(output).to include \
           "Host information",
-          "Architecture: #{RbConfig::CONFIG["host_cpu"]}",
-          "Operating System: #{RbConfig::CONFIG["host_os"]}",
-          "Ruby version: #{RbConfig::CONFIG["RUBY_VERSION_NAME"]}"
+          "Architecture: #{rbconfig["host_cpu"]}",
+          "Operating System: #{rbconfig["host_os"]}",
+          "Ruby version: #{language_version}"
+      end
+
+      it "transmits host information in report" do
+        run
+        host_report = received_report["host"]
+        host_report.delete("running_in_container") # Tested elsewhere
+        expect(host_report).to eq(
+          "architecture" => rbconfig["host_cpu"],
+          "os" => rbconfig["host_os"],
+          "language_version" => language_version,
+          "heroku" => false,
+          "root" => false
+        )
       end
 
       describe "root user detection" do
         context "when not root user" do
-          it "prints no" do
+          it "outputs false" do
+            run
+            expect(output).to include "root user: false"
+          end
+
+          it "transmits root: false in report" do
             run
-            expect(output).to include "root user: no"
+            expect(received_report["host"]["root"]).to eq(false)
           end
         end
 
@@ -104,19 +405,27 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
             run
           end
 
-          it "prints yes, with warning" do
-            expect(output).to include "root user: yes (not recommended)"
+          it "outputs true, with warning" do
+            expect(output).to include "root user: true (not recommended)"
+          end
+
+          it "transmits root: true in report" do
+            expect(received_report["host"]["root"]).to eq(true)
           end
         end
       end
 
       describe "Heroku detection" do
         context "when not on Heroku" do
-          before { recognize_as_container(:none) { run } }
+          before { run }
 
           it "does not output Heroku detection" do
             expect(output).to_not include("Heroku:")
           end
+
+          it "transmits heroku: false in report" do
+            expect(received_report["host"]["heroku"]).to eq(false)
+          end
         end
 
         context "when on Heroku" do
@@ -125,24 +434,41 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
           it "outputs Heroku detection" do
             expect(output).to include("Heroku: true")
           end
+
+          it "transmits heroku: true in report" do
+            expect(received_report["host"]["heroku"]).to eq(true)
+          end
         end
       end
 
       describe "container detection" do
         context "when not in container" do
-          before { recognize_as_container(:none) { run } }
+          before do
+            allow(Appsignal::Extension).to receive(:running_in_container?).and_return(false)
+            run
+          end
 
-          it "does not output container detection" do
-            expect(output).to_not include("Container id:")
+          it "outputs: false" do
+            expect(output).to include("Running in container: false")
+          end
+
+          it "transmits running_in_container: false in report" do
+            expect(received_report["host"]["running_in_container"]).to eq(false)
           end
         end
 
         context "when in container" do
-          before { recognize_as_container(:docker) { run } }
+          before do
+            allow(Appsignal::Extension).to receive(:running_in_container?).and_return(true)
+            run
+          end
 
-          it "outputs container information" do
-            expect(output).to include \
-              "Container id: 0c703b75cdeaad7c933aa68b4678cc5c37a12d5ef5d7cb52c9cefe684d98e575"
+          it "outputs: true" do
+            expect(output).to include("Running in container: true")
+          end
+
+          it "transmits running_in_container: true in report" do
+            expect(received_report["host"]["running_in_container"]).to eq(true)
           end
         end
       end
@@ -155,11 +481,10 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         before do
           ENV.delete("RAILS_ENV") # From spec_helper
           ENV.delete("RACK_ENV")
-          recognize_as_container(:none) { run_within_dir tmp_dir }
+          run_within_dir tmp_dir
         end
 
         it "outputs a warning that no config is loaded" do
-          expect(output).to_not include "Error"
           expect(output).to include \
             "Environment: \n    Warning: No environment set, no config loaded!",
             "  appsignal diagnose --environment=production"
@@ -182,7 +507,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
         it "outputs configuration" do
           expect(output).to include("Configuration")
-          expect(output).to_not include "Error"
           Appsignal.config.config_hash.each do |key, value|
             expect(output).to include("#{key}: #{value}")
           end
@@ -191,7 +515,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
       context "with unconfigured environment" do
         let(:config) { project_fixture_config("foobar") }
-        before { recognize_as_container(:none) { run_within_dir tmp_dir } }
+        before { run_within_dir tmp_dir }
 
         it "outputs environment" do
           expect(output).to include("Environment: foobar")
@@ -199,7 +523,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
         it "outputs config defaults" do
           expect(output).to include("Configuration")
-          expect(output).to_not include "Error"
           Appsignal::Config::DEFAULT_CONFIG.each do |key, value|
             expect(output).to include("#{key}: #{value}")
           end
@@ -215,7 +538,16 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         end
 
         it "outputs valid" do
-          expect(output).to include("Validating API key: Valid")
+          expect(output).to include "Validation",
+            "Validating Push API key: valid"
+        end
+
+        it "transmits validation in report" do
+          expect(received_report).to include(
+            "validation" => {
+              "push_api_key" => "valid"
+            }
+          )
         end
       end
 
@@ -226,7 +558,16 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         end
 
         it "outputs invalid" do
-          expect(output).to include("Validating API key: Invalid")
+          expect(output).to include "Validation",
+            "Validating Push API key: invalid"
+        end
+
+        it "transmits validation in report" do
+          expect(received_report).to include(
+            "validation" => {
+              "push_api_key" => "invalid"
+            }
+          )
         end
       end
 
@@ -237,7 +578,17 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         end
 
         it "outputs failure with status code" do
-          expect(output).to include("Validating API key: Failed with status 500")
+          expect(output).to include "Validation",
+            "Validating Push API key: Failed with status 500\n" +
+            %("Could not confirm authorization: 500")
+        end
+
+        it "transmits validation in report" do
+          expect(received_report).to include(
+            "validation" => {
+              "push_api_key" => %(Failed with status 500\n\"Could not confirm authorization: 500")
+            }
+          )
         end
       end
     end
@@ -250,17 +601,36 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
       end
       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))
+        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 => 0555)
-          FileUtils.chmod(0555, system_tmp_dir)
+          FileUtils.mkdir_p(File.join(root_path, "log"), :mode => 0o555)
+          FileUtils.chmod(0o555, system_tmp_dir)
           run_within_dir root_path
         end
 
         it "outputs unconfigured directory" do
-          expect(output).to include %(log_file_path: ""\n    - Configured?: no)
+          expect(output).to include %(log_file_path: ""\n    Configured?: false)
+        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
+          )
         end
       end
 
@@ -274,29 +644,46 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         end
 
         it "outputs not existing path" do
-          expect(output).to include %(root_path: "#{execution_path}"\n    - Exists?: no)
+          expect(output).to include %(root_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
+          )
         end
       end
 
       describe "ownership" do
+        let(:config) { Appsignal::Config.new(root_path, "production") }
+
         context "when a directory is owned by the current user" do
           let(:root_path) { File.join(tmp_dir, "owned_path") }
-          let(:config) { Appsignal::Config.new(root_path, "production") }
-          let(:process_user) { Etc.getpwuid(Process.uid).name }
           before { run_within_dir root_path }
 
           it "outputs ownership" do
             expect(output).to include \
-              %(root_path: "#{root_path}"\n    - Writable?: yes\n    ) \
-                "- Ownership?: yes (file: #{process_user}:#{Process.uid}, "\
+              %(root_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
+            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 "when a directory is not owned by the current user" do
           let(:root_path) { File.join(tmp_dir, "not_owned_path") }
-          let(:config) { Appsignal::Config.new(root_path, "production") }
-          let(:process_user) { Etc.getpwuid(Process.uid).name }
           before do
             stat = File.stat(root_path)
             allow(stat).to receive(:uid).and_return(0)
@@ -306,61 +693,91 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
           it "outputs no ownership" do
             expect(output).to include \
-              %(root_path: "#{root_path}"\n    - Writable?: yes\n    ) \
-                "- Ownership?: no (file: root:0, process: #{process_user}:#{Process.uid})"
+              %(root_path: "#{root_path}"\n    Writable?: true\n    ) \
+                "Ownership?: false (file: root:0, process: #{process_user}:#{Process.uid})"
           end
         end
       end
 
-      describe "current_path" do
+      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 %(current_path: "#{tmp_dir}"\n    - Writable?: yes)
+          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") }
-          let(:config) { Appsignal::Config.new(root_path, "production") }
           before do
-            FileUtils.chmod(0555, root_path)
+            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?: no)
+            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?: yes),
-              %(log_file_path: "#{system_tmp_log_file}"\n    - Exists?: no)
+              %(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") }
-          let(:config) { Appsignal::Config.new(root_path, "production") }
 
           context "without log dir" do
             before do
-              FileUtils.chmod(0777, root_path)
+              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?: yes)
+              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?: yes),
-                %(log_file_path: "#{system_tmp_log_file}"\n    - Exists?: no)
+                %(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
 
@@ -371,14 +788,19 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
             context "when not writable" do
               before do
-                FileUtils.chmod(0444, log_dir)
+                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?: yes),
-                  %(log_file_path: "#{system_tmp_log_file}"\n    - Exists?: no)
+                  %(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
 
@@ -388,9 +810,14 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
                 it "outputs writable but without log file" do
                   expect(output).to include \
-                    %(root_path: "#{root_path}"\n    - Writable?: yes),
-                    %(log_dir_path: "#{log_dir}"\n    - Writable?: yes),
-                    %(log_file_path: "#{log_file}"\n    - Exists?: no)
+                    %(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
 
@@ -402,19 +829,29 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
                   end
 
                   it "lists log file as writable" do
-                    expect(output).to include %(log_file_path: "#{log_file}"\n    - Writable?: yes)
+                    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(0444, 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?: no)
+                    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
@@ -429,36 +866,57 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
         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 }
 
         context "when file exists" do
           let(:gem_path) { File.join(tmp_dir, "gem") }
+          let(:log_content) do
+            [
+              "log line 1",
+              "log line 2"
+            ]
+          end
           before do
-            FileUtils.mkdir_p ext_path
             File.open log_path, "a" do |f|
-              f.write "log line 1"
-              f.write "log line 2"
+              log_content.each do |line|
+                f.puts line
+              end
             end
             run
           end
 
           it "outputs install.log" do
-            expect(output).to include \
-              %(Path: "#{log_path}"),
-              "log line 1",
-              "log line 2"
+            expect(output).to include(%(Path: "#{log_path}"))
+            expect(output).to include(*log_content)
+          end
+
+          it "transmits log data in report" do
+            expect(received_report["logs"][File.join("ext", log_file)]).to eq(
+              "path" => log_path,
+              "exists" => true,
+              "content" => log_content
+            )
           end
 
           after { FileUtils.rm_rf(gem_path) }
         end
 
         context "when file does not exist" do
-          let(:gem_path) { File.join(tmp_dir, "non_existent_path") }
+          let(:gem_path) { File.join(tmp_dir, "gem_without_log_files") }
           before { run }
 
           it "outputs install.log" do
-            expect(output).to include %(Path: "#{log_path}"\n  File not found.)
+            expect(output).to include %(Path: "#{log_path}"\n    File not found.)
+          end
+
+          it "transmits log data in report" do
+            expect(received_report["logs"][File.join("ext", log_file)]).to eq(
+              "path" => log_path,
+              "exists" => false
+            )
           end
         end
       end
@@ -477,7 +935,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true do
 
         it "outputs header" do
           run
-          expect(output).to include("Extension install log")
+          expect(output).to include("Makefile install log")
         end
       end
     end