appsignal 1.4.0.beta.1 → 2.0.0.beta.1

data/lib/appsignal/cli/notify_of_deploy.rb

@@ -2,9 +2,15 @@ module Appsignal
   class CLI
     class NotifyOfDeploy
       class << self
-        def run(options, config)
+        def run(options)
+          config = config_for(options[:environment])
+          config[:name] = options[:name] if options[:name]
+
           validate_active_config(config)
-          validate_required_options(options, [:revision, :user, :environment])
+          required_config = [:revision, :user]
+          required_config << :environment if config.env.empty?
+          required_config << :name if !config[:name] || config[:name].empty?
+          validate_required_options(options, required_config)
 
           Appsignal::Marker.new(
             {
@@ -15,24 +21,33 @@ module Appsignal
           ).transmit
         end
 
-        protected
+        private
 
         def validate_required_options(options, required_options)
           missing = required_options.select do |required_option|
             val = options[required_option]
             val.nil? || (val.respond_to?(:empty?) && val.empty?)
           end
-          if missing.any?
-            puts "Missing options: #{missing.join(', ')}"
-            exit 1
-          end
+          return unless missing.any?
+
+          puts "Error: Missing options: #{missing.join(', ')}"
+          exit 1
         end
 
         def validate_active_config(config)
-          unless config.active?
-            puts 'Exiting: No config file or push api key env var found'
-            exit 1
-          end
+          return if config.active?
+
+          puts "Error: No valid config found."
+          exit 1
+        end
+
+        def config_for(environment)
+          Appsignal::Config.new(
+            Dir.pwd,
+            environment,
+            {},
+            Logger.new(StringIO.new)
+          )
         end
       end
     end

data/lib/appsignal/config.rb

@@ -8,6 +8,7 @@ module Appsignal
     SYSTEM_TMP_DIR = '/tmp'
     DEFAULT_CONFIG = {
       :debug                          => false,
+      :log                            => 'file',
       :ignore_errors                  => [],
       :ignore_actions                 => [],
       :filter_parameters              => [],
@@ -35,6 +36,7 @@ module Appsignal
       'APPSIGNAL_PUSH_API_ENDPOINT'              => :endpoint,
       'APPSIGNAL_FRONTEND_ERROR_CATCHING_PATH'   => :frontend_error_catching_path,
       'APPSIGNAL_DEBUG'                          => :debug,
+      'APPSIGNAL_LOG'                            => :log,
       'APPSIGNAL_LOG_PATH'                       => :log_path,
       'APPSIGNAL_INSTRUMENT_NET_HTTP'            => :instrument_net_http,
       'APPSIGNAL_INSTRUMENT_REDIS'               => :instrument_redis,
@@ -96,7 +98,7 @@ module Appsignal
       if File.writable? SYSTEM_TMP_DIR
         $stdout.puts "appsignal: Unable to log to '#{path}'. Logging to "\
           "'#{SYSTEM_TMP_DIR}' instead. Please check the "\
-          "permissions for the application's log directory."
+          "permissions for the application's (log) directory."
         File.join(SYSTEM_TMP_DIR, 'appsignal.log')
       else
         $stdout.puts "appsignal: Unable to log to '#{path}' or the "\
@@ -119,7 +121,7 @@ module Appsignal
       ENV['APPSIGNAL_AGENT_PATH']                   = File.expand_path('../../../ext', __FILE__).to_s
       ENV['APPSIGNAL_ENVIRONMENT']                  = env
       ENV['APPSIGNAL_AGENT_VERSION']                = Appsignal::Extension.agent_version
-      ENV['APPSIGNAL_LANGUAGE_INTEGRATION_VERSION'] = Appsignal::VERSION
+      ENV['APPSIGNAL_LANGUAGE_INTEGRATION_VERSION'] = "ruby-#{Appsignal::VERSION}"
       ENV['APPSIGNAL_DEBUG_LOGGING']                = config_hash[:debug].to_s
       ENV['APPSIGNAL_LOG_FILE_PATH']                = log_file_path.to_s if log_file_path
       ENV['APPSIGNAL_PUSH_API_ENDPOINT']            = config_hash[:endpoint]
@@ -146,7 +148,8 @@ module Appsignal
     end
 
     def detect_from_system
-      self[:running_in_container] = true if Appsignal::System.container?
+      config_hash[:running_in_container] = true if Appsignal::System.container?
+      config_hash[:log] = 'stdout' if Appsignal::System.heroku?
     end
 
     def load_from_disk
@@ -184,8 +187,9 @@ module Appsignal
 
       # Configuration with string type
       %w(APPSIGNAL_PUSH_API_KEY APPSIGNAL_APP_NAME APPSIGNAL_PUSH_API_ENDPOINT
-         APPSIGNAL_FRONTEND_ERROR_CATCHING_PATH APPSIGNAL_HTTP_PROXY APPSIGNAL_LOG_PATH
-         APPSIGNAL_WORKING_DIR_PATH APPSIGNAL_HOSTNAME APPSIGNAL_CA_FILE_PATH).each do |var|
+         APPSIGNAL_FRONTEND_ERROR_CATCHING_PATH APPSIGNAL_HTTP_PROXY
+         APPSIGNAL_LOG APPSIGNAL_LOG_PATH APPSIGNAL_WORKING_DIR_PATH
+         APPSIGNAL_HOSTNAME APPSIGNAL_CA_FILE_PATH).each do |var|
         if env_var = ENV[var]
           config[ENV_TO_KEY_MAPPING[var]] = env_var
         end

data/lib/appsignal/integrations/grape.rb

@@ -1,41 +1,48 @@
 module Appsignal
   module Grape
     class Middleware < ::Grape::Middleware::Base
-      def initialize(app)
-        @app = app
-      end
-
       def call(env)
         if Appsignal.active?
           call_with_appsignal_monitoring(env)
         else
-          @app.call(env)
+          app.call(env)
         end
       end
 
       def call_with_appsignal_monitoring(env)
-        request      = ::Rack::Request.new(env)
-        transaction  = Appsignal::Transaction.create(
+        request     = ::Rack::Request.new(env)
+        transaction = Appsignal::Transaction.create(
           SecureRandom.uuid,
           Appsignal::Transaction::HTTP_REQUEST,
           request
         )
         begin
-          @app.call(env)
+          app.call(env)
         rescue => error
           transaction.set_error(error)
           raise error
         ensure
-          api_endpoint = env['api.endpoint']
-          if api_endpoint && options = api_endpoint.options
-            method = options[:method].first
-            klass  = options[:for]
-            action = options[:path].first
-            transaction.set_action("#{method}::#{klass}##{action}")
+          request_method = request.request_method
+          path = request.path # Path without namespaces
+          endpoint = env["api.endpoint"]
+
+          if endpoint && endpoint.options
+            options = endpoint.options
+            request_method = options[:method].first
+            klass = options[:for]
+            namespace = endpoint.namespace
+            namespace = "" if namespace == "/"
+
+            path = options[:path].first.to_s
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
+
+            transaction.set_action("#{request_method}::#{klass}##{path}")
           end
+
           transaction.set_http_or_background_queue_start
-          transaction.set_metadata('path', request.path)
-          transaction.set_metadata('method', env['REQUEST_METHOD'])
+          transaction.set_metadata("path", path)
+          transaction.set_metadata("method", request_method)
           Appsignal::Transaction.complete_current!
         end
       end

data/lib/appsignal/js_exception_transaction.rb

@@ -14,7 +14,7 @@ module Appsignal
     end
 
     def set_action
-      @ext.set_action(@data['action'])
+      @ext.set_action(@data['action']) if @data['action']
     end
 
     def set_metadata
@@ -26,8 +26,8 @@ module Appsignal
     def set_error
       @ext.set_error(
         @data['name'],
-        @data['message'],
-        Appsignal::Utils.data_generate(@data['backtrace'])
+        @data['message'] || '',
+        Appsignal::Utils.data_generate(@data['backtrace'] || [])
       )
     end
 

data/lib/appsignal/marker.rb

@@ -10,16 +10,17 @@ module Appsignal
 
     def transmit
       transmitter = Transmitter.new(ACTION, config)
-      puts "Notifying Appsignal of deploy with: "\
+      puts "Notifying AppSignal of deploy with: "\
         "revision: #{marker_data[:revision]}, user: #{marker_data[:user]}"
+
       result = transmitter.transmit(marker_data)
       if result == '200'
-        puts 'Appsignal has been notified of this deploy!'
+        puts 'AppSignal has been notified of this deploy!'
       else
         raise "#{result} at #{transmitter.uri}"
       end
     rescue => e
-      puts "Something went wrong while trying to notify Appsignal: #{e}"
+      puts "Something went wrong while trying to notify AppSignal: #{e}"
     end
   end
 end

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -8,11 +8,18 @@ module Appsignal
 
       def call(env)
         if env['PATH_INFO'] == Appsignal.config[:frontend_error_catching_path]
-          body        = JSON.parse(env['rack.input'].read)
-          transaction = JSExceptionTransaction.new(body)
-          transaction.complete!
+          body = JSON.parse(env['rack.input'].read)
 
-          return [ 200, {}, []]
+          if body['name'].is_a?(String) && body['name'].length > 0
+            transaction = JSExceptionTransaction.new(body)
+            transaction.complete!
+            code = 200
+          else
+            Appsignal.logger.debug "JSExceptionCatcher: Could not send exception, 'name' is empty."
+            code = 422
+          end
+
+          return [code, {}, []]
         else
           @app.call(env)
         end

data/lib/appsignal/utils.rb

@@ -3,17 +3,6 @@ require 'appsignal/utils/query_params_sanitizer'
 
 module Appsignal
   module Utils
-    module ClassMethods
-      extend Gem::Deprecate
-
-      def sanitize(params, only_top_level = false, key_sanitizer = nil)
-        QueryParamsSanitizer.sanitize(params, only_top_level, key_sanitizer)
-      end
-
-      deprecate :sanitize, "AppSignal::Utils::QueryParamsSanitizer.sanitize", 2016, 9
-    end
-    extend ClassMethods
-
     def self.data_generate(body)
       Data.generate(body)
     end
@@ -126,5 +115,4 @@ module Appsignal
       end
     end
   end
-
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require 'yaml'
 
 module Appsignal
-  VERSION = '1.4.0.beta.1'
+  VERSION = '2.0.0.beta.1'
 end

data/spec/lib/appsignal/capistrano2_spec.rb

@@ -134,8 +134,8 @@ if DependencyHelper.capistrano2_present?
             capistrano_config.find_and_execute_task('appsignal:deploy')
 
             expect(out_stream.string).to include \
-              'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-              'Appsignal has been notified of this deploy!'
+              'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+              'AppSignal has been notified of this deploy!'
           end
 
           context "with overridden revision" do
@@ -147,8 +147,8 @@ if DependencyHelper.capistrano2_present?
 
             it "transmits the overriden revision" do
               expect(out_stream.string).to include \
-                'Notifying Appsignal of deploy with: revision: abc123, user: batman',
-                'Appsignal has been notified of this deploy!'
+                'Notifying AppSignal of deploy with: revision: abc123, user: batman',
+                'AppSignal has been notified of this deploy!'
             end
           end
 
@@ -161,9 +161,9 @@ if DependencyHelper.capistrano2_present?
             it "does not transmit marker" do
               output = out_stream.string
               expect(output).to include \
-                'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-                'Something went wrong while trying to notify Appsignal:'
-              expect(output).to_not include 'Appsignal has been notified of this deploy!'
+                'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+                'Something went wrong while trying to notify AppSignal:'
+              expect(output).to_not include 'AppSignal has been notified of this deploy!'
             end
           end
 

data/spec/lib/appsignal/capistrano3_spec.rb

@@ -135,8 +135,8 @@ if DependencyHelper.capistrano3_present?
             invoke('appsignal:deploy')
 
             expect(out_stream.string).to include \
-              'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-              'Appsignal has been notified of this deploy!'
+              'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+              'AppSignal has been notified of this deploy!'
           end
 
           context "with overridden revision" do
@@ -148,8 +148,8 @@ if DependencyHelper.capistrano3_present?
 
             it "transmits the overriden revision" do
               expect(out_stream.string).to include \
-                'Notifying Appsignal of deploy with: revision: abc123, user: batman',
-                'Appsignal has been notified of this deploy!'
+                'Notifying AppSignal of deploy with: revision: abc123, user: batman',
+                'AppSignal has been notified of this deploy!'
             end
           end
 
@@ -162,9 +162,9 @@ if DependencyHelper.capistrano3_present?
             it "does not transmit marker" do
               output = out_stream.string
               expect(output).to include \
-                'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-                'Something went wrong while trying to notify Appsignal:'
-              expect(output).to_not include 'Appsignal has been notified of this deploy!'
+                'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+                'Something went wrong while trying to notify AppSignal:'
+              expect(output).to_not include 'AppSignal has been notified of this deploy!'
             end
           end
         end

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

@@ -1,29 +1,336 @@
-require 'appsignal/cli'
+require "appsignal/cli"
 
 describe Appsignal::CLI::Diagnose do
-  let(:out_stream) { StringIO.new }
-  let(:config) { project_fixture_config }
-  let(:cli) { described_class }
-  around do |example|
-    capture_stdout(out_stream) { example.run }
-  end
-
   describe ".run" do
+    let(:out_stream) { StringIO.new }
+    let(:config) { project_fixture_config }
+    let(:cli) { described_class }
+    let(:output) { out_stream.string }
     before do
-      Appsignal.config = config
-      stub_api_request config, 'auth'
-    end
-
-    it "should output diagnostic information" do
-      cli.run
-      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')
+      ENV["APPSIGNAL_APP_ENV"] = "production"
+      stub_api_request config, "auth"
+    end
+    after { Appsignal.config = nil }
+    around { |example| capture_stdout(out_stream) { example.run } }
+
+    def run
+      run_within_dir project_fixture_path
+    end
+
+    def run_within_dir(chdir)
+      Dir.chdir chdir do
+        cli.run
+      end
+    end
+
+    it "outputs header and support text" do
+      run
+      expect(output).to include \
+        "AppSignal diagnose",
+        "http://docs.appsignal.com/",
+        "support@appsignal.com"
+    end
+
+    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
+
+    describe "host information" do
+      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"]}"
+      end
+
+      describe "Heroku detection" do
+        context "when not on Heroku" do
+          before { recognize_as_container(:none) { run } }
+
+          it "does not output Heroku detection" do
+            expect(output).to_not include("Heroku:")
+          end
+        end
+
+        context "when on Heroku" do
+          before { recognize_as_heroku { run } }
+
+          it "outputs Heroku detection" do
+            expect(output).to include("Heroku: true")
+          end
+        end
+      end
+
+      describe "container detection" do
+        context "when not in container" do
+          before { recognize_as_container(:none) { run } }
+
+          it "does not output container detection" do
+            expect(output).to_not include("Container id:")
+          end
+        end
+
+        context "when in container" do
+          before { recognize_as_container(:docker) { run } }
+
+          it "outputs container information" do
+            expect(output).to include \
+              "Container id: 0c703b75cdeaad7c933aa68b4678cc5c37a12d5ef5d7cb52c9cefe684d98e575"
+          end
+        end
+      end
+    end
+
+    describe "configuration" do
+      context "without extension" do
+        before do
+          # When the extension isn't loaded the Appsignal.start operation exits
+          # early and doesn't load the configuration.
+          # Happens when the extension wasn't installed properly.
+          Appsignal.extension_loaded = false
+          run
+        end
+        after { Appsignal.extension_loaded = true }
+
+        it "outputs an error" do
+          expect(output).to include \
+            "Error: No config found!\nCould not start AppSignal."
+        end
+
+        it "outputs as much as it can" do
+          expect(output).to include \
+            "AppSignal agent\n  Gem version: #{Appsignal::VERSION}",
+            "Host information\n  Architecture: ",
+            %(Extension install log\n  Path: "),
+            %(Makefile install log\n  Path: ")
+        end
+      end
+
+      context "without environment" do
+        let(:config) { project_fixture_config("") }
+        before do
+          ENV["APPSIGNAL_APP_ENV"] = ""
+          recognize_as_container(:none) { run }
+        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_APP_ENV=production appsignal diagnose"
+        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
+        end
+      end
+
+      context "with configured environment" do
+        before { run }
+
+        it "outputs environment" do
+          expect(output).to include("Environment: production")
+        end
+
+        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
+        end
+      end
+
+      context "with unconfigured environment" do
+        let(:config) { project_fixture_config("foobar") }
+        before do
+          ENV["APPSIGNAL_APP_ENV"] = "foobar"
+          recognize_as_container(:none) { run }
+        end
+
+        it "outputs environment" do
+          expect(output).to include("Environment: foobar")
+        end
+
+        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
+        end
+      end
+    end
+
+    describe "API key validation" do
+      context "with valid key" do
+        before do
+          stub_api_request(config, "auth").to_return(:status => 200)
+          run
+        end
+
+        it "outputs valid" do
+          expect(output).to include("Validating API key: Valid")
+        end
+      end
+
+      context "with invalid key" do
+        before do
+          stub_api_request(config, "auth").to_return(:status => 401)
+          run
+        end
+
+        it "outputs invalid" do
+          expect(output).to include("Validating API key: Invalid")
+        end
+      end
+
+      context "with invalid key" do
+        before do
+          stub_api_request(config, "auth").to_return(:status => 500)
+          run
+        end
+
+        it "outputs failure with status code" do
+          expect(output).to include("Validating API key: Failed with status 500")
+        end
+      end
+    end
+
+    describe "paths" do
+      before { FileUtils.mkdir_p(root_path) }
+
+      context "when a directory is writable" do
+        let(:root_path) { File.join(tmp_dir, "writable_path") }
+        let(:log_file) { File.join(root_path, "appsignal.log") }
+        let(:config) { Appsignal::Config.new(root_path, "production") }
+
+        context "without log file" do
+          before { run_within_dir root_path }
+
+          it "outputs writable" do
+            expect(output).to include \
+              "Required paths",
+              %(root_path: "#{root_path}" - Writable),
+              %(log_file_path: "#{log_file}" - Does not exist)
+          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 \
+                %(root_path: "#{root_path}" - Writable),
+                %(log_file_path: "#{File.join(root_path, "appsignal.log")}" - Writable)
+            end
+          end
+
+          context "when not writable" do
+            before do
+              FileUtils.touch(log_file)
+              FileUtils.chmod(0444, log_file)
+              run_within_dir root_path
+            end
+
+            it "lists log file as not writable" do
+              expect(output).to include \
+                %(root_path: "#{root_path}" - Writable),
+                %(log_file_path: "#{File.join(root_path, "appsignal.log")}" - Not writable)
+            end
+          end
+        end
+      end
+
+      context "when a directory is 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)
+          run_within_dir root_path
+        end
+
+        it "outputs not writable" do
+          expect(output).to include \
+            "Required paths",
+            %(root_path: "#{root_path}" - Not writable),
+            %(log_file_path: "" - Not writable)
+        end
+      end
+
+      after { FileUtils.rm_rf(root_path) }
+    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
+          allow(cli).to receive(:gem_path).and_return(gem_path)
+        end
+
+        context "when file exists" do
+          let(:gem_path) { File.join(tmp_dir, "gem") }
+          before do
+            FileUtils.mkdir_p ext_path
+            File.open log_path, "a" do |f|
+              f.write "log line 1"
+              f.write "log line 2"
+            end
+            run
+          end
+
+          it "outputs install.log" do
+            expect(output).to include \
+              %(Path: "#{log_path}"),
+              "log line 1",
+              "log line 2"
+          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") }
+          before { run }
+
+          it "outputs install.log" do
+            expect(output).to include %(Path: "#{log_path}"\n  File not found.)
+          end
+        end
+      end
+
+      describe "install.log" do
+        it_behaves_like "ext log file", "install.log"
+
+        it "outputs header" do
+          run
+          expect(output).to include("Extension install log")
+        end
+      end
+
+      describe "mkmf.log" do
+        it_behaves_like "ext log file", "mkmf.log"
+
+        it "outputs header" do
+          run
+          expect(output).to include("Extension install log")
+        end
+      end
     end
   end
 end