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

data/lib/appsignal/cli/demo.rb

@@ -54,8 +54,11 @@ module Appsignal
             puts "Demonstration sample data sent!"
             puts "It may take about a minute for the data to appear on https://appsignal.com/accounts"
           else
-            puts "Error: Unable to start the AppSignal agent and send data to AppSignal.com"
-            puts "Please use `appsignal diagnose` to debug your configuration."
+            puts "\nError: Unable to start the AppSignal agent and send data to AppSignal.com."
+            puts "Please use the diagnose command (https://docs.appsignal.com/ruby/command-line/diagnose.html) to debug your configuration:"
+            puts
+            puts "    bundle exec appsignal diagnose --environment=production"
+            puts
             exit 1
           end
         end

data/lib/appsignal/cli/diagnose.rb

@@ -82,6 +82,8 @@ module Appsignal
           print_empty_line
 
           library_information
+          data[:installation] = fetch_installation_report
+          print_installation_report
           print_empty_line
 
           host_information
@@ -180,7 +182,8 @@ module Appsignal
           if rails_app?
             data[:app][:rails] = true
             current_path = Rails.root
-            initial_config[:name] = Rails.application.class.parent_name
+            initial_config[:name] =
+              Appsignal::Utils::RailsHelper.detected_rails_app_name
             initial_config[:log_path] = current_path.join("log")
           end
 
@@ -325,12 +328,89 @@ module Appsignal
             save :language, "ruby"
             puts_and_save :package_version, "Gem version", Appsignal::VERSION
             puts_and_save :agent_version, "Agent version", Appsignal::Extension.agent_version
-            puts_and_save :agent_architecture, "Agent architecture",
-              Appsignal::System.installed_agent_architecture
             puts_and_save :extension_loaded, "Extension loaded", Appsignal.extension_loaded
           end
         end
 
+        def fetch_installation_report
+          path = File.expand_path("../../../../ext/install.report", __FILE__)
+          raw_report = File.read(path)
+          Utils.parse_yaml(raw_report)
+        rescue => e
+          {
+            "parsing_error" => {
+              "error" => "#{e.class}: #{e}",
+              "backtrace" => e.backtrace
+            }.tap do |r|
+              r["raw"] = raw_report if raw_report
+            end
+          }
+        end
+
+        def print_installation_report
+          puts "\nExtension installation report"
+          install_report = data[:installation]
+          if install_report.key? "parsing_error"
+            print_installation_report_parsing_error(install_report)
+            return
+          end
+
+          print_installation_result_report(install_report)
+          print_installation_language_report(install_report)
+          print_installation_download_report(install_report)
+          print_installation_build_report(install_report)
+          print_installation_host_report(install_report)
+        end
+
+        def print_installation_report_parsing_error(report)
+          report = report["parsing_error"]
+          puts "  Error found while parsing the report."
+          puts "  Error: #{report["error"]}"
+          puts "  Raw report:\n#{report["raw"]}" if report["raw"]
+        end
+
+        def print_installation_result_report(report)
+          report = report.fetch("download", {})
+          puts "  Installation result"
+          puts "    Status: #{report["status"]}"
+          puts "    Message: #{report["message"]}" if report["message"]
+          puts "    Error: #{report["error"]}" if report["error"]
+        end
+
+        def print_installation_language_report(report)
+          report = report.fetch("language", {})
+          puts "  Language details"
+          puts "    Implementation: #{report["implementation"]}"
+          puts "    Ruby version: #{report["version"]}"
+        end
+
+        def print_installation_download_report(report)
+          report = report.fetch("download", {})
+          puts "  Download details"
+          puts "    Download URL: #{report["download_url"]}"
+          puts "    Checksum: #{report["checksum"]}"
+        end
+
+        def print_installation_build_report(report)
+          report = report.fetch("build", {})
+          puts "  Build details"
+          puts "    Install time: #{report["time"]}"
+          puts "    Architecture: #{report["architecture"]}"
+          puts "    Target: #{report["target"]}"
+          puts "    Musl override: #{report["musl_override"]}"
+          puts "    Library type: #{report["library_type"]}"
+          puts "    Source: #{report["source"]}" if report["source"] != "remote"
+          puts "    Dependencies: #{report["dependencies"]}"
+          puts "    Flags: #{report["flags"]}"
+        end
+
+        def print_installation_host_report(report)
+          report = report.fetch("host", {})
+          puts "  Host details"
+          puts "    Root user: #{report["root_user"]}"
+          puts "    Dependencies: #{report["dependencies"]}"
+        end
+
         def host_information
           rbconfig = RbConfig::CONFIG
           puts "Host information"
@@ -349,7 +429,7 @@ module Appsignal
             save :heroku, Appsignal::System.heroku?
 
             save :root, Process.uid.zero?
-            puts_value "root user",
+            puts_value "Root user",
               Process.uid.zero? ? "true (not recommended)" : "false"
             puts_and_save :running_in_container, "Running in container",
               Appsignal::Extension.running_in_container?

data/lib/appsignal/cli/diagnose/paths.rb

@@ -17,7 +17,6 @@ module Appsignal
             begin
               config = Appsignal.config
               log_file_path = config.log_file_path
-              install_log_path = File.join("ext", "install.log")
               makefile_log_path = File.join("ext", "mkmf.log")
               {
                 :package_install_path => {
@@ -36,10 +35,6 @@ module Appsignal
                   :label => "Log directory",
                   :path => log_file_path ? File.dirname(log_file_path) : ""
                 },
-                install_log_path => {
-                  :label => "Extension install log",
-                  :path => File.join(gem_path, install_log_path)
-                },
                 makefile_log_path => {
                   :label => "Makefile install log",
                   :path => File.join(gem_path, makefile_log_path)

data/lib/appsignal/cli/diagnose/utils.rb

@@ -6,12 +6,14 @@ module Appsignal
           passwd_struct = Etc.getpwuid(uid)
           return unless passwd_struct
           passwd_struct.name
+        rescue ArgumentError # rubocop:disable Lint/HandleExceptions
         end
 
         def self.group_for_gid(gid)
           passwd_struct = Etc.getgrgid(gid)
           return unless passwd_struct
           passwd_struct.name
+        rescue ArgumentError # rubocop:disable Lint/HandleExceptions
         end
 
         def self.read_file_content(path, bytes_to_read)
@@ -30,6 +32,23 @@ module Appsignal
 
           IO.binread(path, length, offset)
         end
+
+        def self.parse_yaml(contents)
+          arguments = [contents]
+          if YAML.respond_to? :safe_load
+            method = :safe_load
+            arguments << \
+              if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
+                # Use keyword params for Ruby 2.6 and up
+                { :permitted_classes => [Time] }
+              else
+                [Time]
+              end
+          else
+            method = :load
+          end
+          YAML.send(method, *arguments)
+        end
       end
     end
   end

data/lib/appsignal/cli/helpers.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require "appsignal/utils/rails_helper"
+
 module Appsignal
   class CLI
     module Helpers
       private
 
+      def ruby_2_6_or_up?
+        Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
+      end
+
       def colorize(text, color)
         return text if Gem.win_platform?
 

data/lib/appsignal/cli/install.rb

@@ -75,19 +75,39 @@ module Appsignal
         def install_for_rails(config)
           puts "Installing for Ruby on Rails"
 
-          require File.expand_path(File.join(Dir.pwd, "config/application.rb"))
+          name_overwritten = configure_rails_app_name(config)
+          configure(config, rails_environments, name_overwritten)
+          done_notice
+        end
 
-          config[:name] = Rails.application.class.parent_name
+        def configure_rails_app_name(config)
+          loaded =
+            begin
+              load Appsignal::Utils::RailsHelper.application_config_path
+              true
+            rescue LoadError, StandardError
+              false
+            end
 
-          name_overwritten = yes_or_no("  Your app's name is: '#{config[:name]}' \n  Do you want to change how this is displayed in AppSignal? (y/n): ")
-          puts
-          if name_overwritten
-            config[:name] = required_input("  Choose app's display name: ")
+          name_overwritten = false
+          if loaded
+            config[:name] = Appsignal::Utils::RailsHelper.detected_rails_app_name
+            puts
+            name_overwritten = yes_or_no(
+              "  Your app's name is: '#{config[:name]}' \n  " \
+                "Do you want to change how this is displayed in AppSignal? " \
+                "(y/n): "
+            )
+            if name_overwritten
+              config[:name] = required_input("  Choose app's display name: ")
+              puts
+            end
+          else
+            puts "  Unable to automatically detect your Rails app's name."
+            config[:name] = required_input("  Choose your app's display name for AppSignal.com: ")
             puts
           end
-
-          configure(config, rails_environments, name_overwritten)
-          done_notice
+          name_overwritten
         end
 
         def install_for_sinatra(config)
@@ -228,7 +248,10 @@ module Appsignal
 
         def installed_frameworks
           [].tap do |out|
-            out << :rails if framework_available? "rails"
+            if framework_available?("rails") &&
+                File.exist?(Appsignal::Utils::RailsHelper.application_config_path)
+              out << :rails
+            end
             out << :sinatra if framework_available? "sinatra"
             out << :padrino if framework_available? "padrino"
             out << :grape if framework_available? "grape"
@@ -249,12 +272,19 @@ module Appsignal
         end
 
         def write_config_file(data)
-          template = ERB.new(
-            File.read(File.join(File.dirname(__FILE__), "../../../resources/appsignal.yml.erb")),
-            nil,
-            "-"
+          filename = File.join(
+            File.dirname(__FILE__),
+            "../../../resources/appsignal.yml.erb"
           )
-
+          file_contents = File.read(filename)
+          arguments = [file_contents]
+          if ruby_2_6_or_up?
+            arguments << { :trim_mode => "-" }
+          else
+            arguments << nil
+            arguments << "-"
+          end
+          template = ERB.new(*arguments)
           config = template.result(OpenStruct.new(data).instance_eval { binding })
 
           FileUtils.mkdir_p(File.join(Dir.pwd, "config"))

data/lib/appsignal/cli/notify_of_deploy.rb

@@ -60,6 +60,8 @@ module Appsignal
     #   Terminology: Deploy marker
     class NotifyOfDeploy
       class << self
+        include Appsignal::Utils::DeprecationMessage
+
         # @param options [Hash]
         # @option options :environment [String] environment to load
         #   configuration for.
@@ -85,6 +87,14 @@ module Appsignal
             },
             config
           ).transmit
+
+          puts
+          message = "This command (appsignal notify_of_deploy) has been " \
+            "deprecated in favor of the `revision` config option. Please " \
+            "see our documentation for more information on the recommended " \
+            "method: " \
+            "https://docs.appsignal.com/application/markers/deploy-markers.html"
+          deprecation_message message, Appsignal.logger
         end
 
         private

data/lib/appsignal/config.rb

@@ -36,7 +36,7 @@ module Appsignal
       :enable_allocation_tracking     => true,
       :enable_gc_instrumentation      => false,
       :enable_host_metrics            => true,
-      :enable_minutely_probes         => false,
+      :enable_minutely_probes         => true,
       :ca_file_path                   => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
       :dns_servers                    => [],
       :files_world_accessible         => true
@@ -214,7 +214,6 @@ module Appsignal
       ENV["_APPSIGNAL_WORKING_DIR_PATH"]             = config_hash[:working_dir_path] if config_hash[:working_dir_path]
       ENV["_APPSIGNAL_WORKING_DIRECTORY_PATH"]       = config_hash[:working_directory_path] if config_hash[:working_directory_path]
       ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]          = config_hash[:enable_host_metrics].to_s
-      ENV["_APPSIGNAL_ENABLE_MINUTELY_PROBES"]       = config_hash[:enable_minutely_probes].to_s
       ENV["_APPSIGNAL_HOSTNAME"]                     = config_hash[:hostname].to_s
       ENV["_APPSIGNAL_PROCESS_NAME"]                 = $PROGRAM_NAME
       ENV["_APPSIGNAL_CA_FILE_PATH"]                 = config_hash[:ca_file_path].to_s

data/lib/appsignal/event_formatter.rb

@@ -75,16 +75,15 @@ module Appsignal
 
       def initialize_formatter(name, formatter)
         format_method = formatter.instance_method(:format)
-        if format_method && format_method.arity == 1
-          formatter_classes[name] = formatter
-          formatters[name] = formatter.new
-        else
+        if !format_method || format_method.arity != 1
           raise "#{formatter} does not have a format(payload) method"
         end
+        formatter_classes[name] = formatter
+        formatters[name] = formatter.new
       rescue => ex
         formatter_classes.delete(name)
         formatters.delete(name)
-        logger.warn("'#{ex.message}' when initializing #{name} event formatter")
+        logger.error("'#{ex.message}' when initializing #{name} event formatter")
       end
 
       def register_deprecated_formatter(name)

data/lib/appsignal/event_formatter/action_view/render_formatter.rb

@@ -22,11 +22,13 @@ module Appsignal
   end
 end
 
-Appsignal::EventFormatter.register(
-  "render_partial.action_view",
-  Appsignal::EventFormatter::ActionView::RenderFormatter
-)
-Appsignal::EventFormatter.register(
-  "render_template.action_view",
-  Appsignal::EventFormatter::ActionView::RenderFormatter
-)
+if defined?(Rails)
+  Appsignal::EventFormatter.register(
+    "render_partial.action_view",
+    Appsignal::EventFormatter::ActionView::RenderFormatter
+  )
+  Appsignal::EventFormatter.register(
+    "render_template.action_view",
+    Appsignal::EventFormatter::ActionView::RenderFormatter
+  )
+end

data/lib/appsignal/event_formatter/moped/query_formatter.rb

@@ -6,65 +6,66 @@ module Appsignal
     module Moped
       class QueryFormatter
         def format(payload)
-          if payload[:ops] && !payload[:ops].empty?
-            op = payload[:ops].first
-            case op.class.to_s
-            when "Moped::Protocol::Command"
-              [
-                "Command", {
-                  :database => op.full_collection_name,
-                  :selector => sanitize(op.selector, true, :mongodb)
-                }.inspect
-              ]
-            when "Moped::Protocol::Query"
-              [
-                "Query", {
-                  :database => op.full_collection_name,
-                  :selector => sanitize(op.selector, false, :mongodb),
-                  :flags    => op.flags,
-                  :limit    => op.limit,
-                  :skip     => op.skip,
-                  :fields   => op.fields
-                }.inspect
-              ]
-            when "Moped::Protocol::Delete"
-              [
-                "Delete", {
-                  :database => op.full_collection_name,
-                  :selector => sanitize(op.selector, false, :mongodb),
-                  :flags    => op.flags
-                }.inspect
-              ]
-            when "Moped::Protocol::Insert"
-              [
-                "Insert", {
-                  :database   => op.full_collection_name,
-                  :documents  => sanitize(op.documents, true, :mongodb),
-                  :count      => op.documents.count,
-                  :flags      => op.flags
-                }.inspect
-              ]
-            when "Moped::Protocol::Update"
-              [
-                "Update",
-                {
-                  :database => op.full_collection_name,
-                  :selector => sanitize(op.selector, false, :mongodb),
-                  :update   => sanitize(op.update, true, :mongodb),
-                  :flags    => op.flags
-                }.inspect
-              ]
-            when "Moped::Protocol::KillCursors"
-              [
-                "KillCursors",
-                { :number_of_cursor_ids => op.number_of_cursor_ids }.inspect
-              ]
-            else
-              [
-                op.class.to_s.sub("Moped::Protocol::", ""),
-                { :database => op.full_collection_name }.inspect
-              ]
-            end
+          return unless payload[:ops]
+          return if payload[:ops].empty?
+
+          op = payload[:ops].first
+          case op.class.to_s
+          when "Moped::Protocol::Command"
+            [
+              "Command", {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector, true, :mongodb)
+              }.inspect
+            ]
+          when "Moped::Protocol::Query"
+            [
+              "Query", {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector, false, :mongodb),
+                :flags    => op.flags,
+                :limit    => op.limit,
+                :skip     => op.skip,
+                :fields   => op.fields
+              }.inspect
+            ]
+          when "Moped::Protocol::Delete"
+            [
+              "Delete", {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector, false, :mongodb),
+                :flags    => op.flags
+              }.inspect
+            ]
+          when "Moped::Protocol::Insert"
+            [
+              "Insert", {
+                :database   => op.full_collection_name,
+                :documents  => sanitize(op.documents, true, :mongodb),
+                :count      => op.documents.count,
+                :flags      => op.flags
+              }.inspect
+            ]
+          when "Moped::Protocol::Update"
+            [
+              "Update",
+              {
+                :database => op.full_collection_name,
+                :selector => sanitize(op.selector, false, :mongodb),
+                :update   => sanitize(op.update, true, :mongodb),
+                :flags    => op.flags
+              }.inspect
+            ]
+          when "Moped::Protocol::KillCursors"
+            [
+              "KillCursors",
+              { :number_of_cursor_ids => op.number_of_cursor_ids }.inspect
+            ]
+          else
+            [
+              op.class.to_s.sub("Moped::Protocol::", ""),
+              { :database => op.full_collection_name }.inspect
+            ]
           end
         end