appsignal 2.5.0.alpha.1-java

data/lib/appsignal/auth_check.rb

@@ -0,0 +1,65 @@
+module Appsignal
+  # Class used to perform a Push API validation / authentication check against
+  # the AppSignal Push API.
+  #
+  # @example
+  #   config = Appsignal::Config.new(Dir.pwd, "production")
+  #   auth_check = Appsignal::AuthCheck.new(config)
+  #   # Valid push_api_key
+  #   auth_check.perform # => "200"
+  #   # Invalid push_api_key
+  #   auth_check.perform # => "401"
+  #
+  # @!attribute [r] config
+  #   @return [Appsignal::Config] config to use in the authentication request.
+  # @api private
+  class AuthCheck
+    # Path used on the AppSignal Push API
+    # https://push.appsignal.com/1/auth
+    ACTION = "auth".freeze
+
+    attr_reader :config, :logger
+
+    def initialize(config, logger = nil)
+      @config = config
+      if logger # rubocop:disable Style/GuardClause
+        warn "Deprecated: `logger` argument will be removed in the next " \
+          "major version."
+      end
+    end
+
+    # Perform push api validation request and return response status code.
+    #
+    # @return [String] response status code.
+    # @raise [StandardError] see {Appsignal::Transmitter#transmit}.
+    def perform
+      Appsignal::Transmitter.new(ACTION, config).transmit({}).code
+    end
+
+    # Perform push api validation request and return a descriptive response
+    # tuple.
+    #
+    # @return [Array<String/nil, String>] response tuple.
+    #   - First value is the response status code.
+    #   - Second value is a description of the response and the exception error
+    #     message if an exception occured.
+    def perform_with_result
+      status = perform
+      result =
+        case status
+        when "200"
+          "AppSignal has confirmed authorization!"
+        when "401"
+          "API key not valid with AppSignal..."
+        else
+          "Could not confirm authorization: " \
+            "#{status.nil? ? "nil" : status}"
+        end
+      [status, result]
+    rescue => e
+      result = "Something went wrong while trying to "\
+               "authenticate with AppSignal: #{e}"
+      [nil, result]
+    end
+  end
+end

data/lib/appsignal/capistrano.rb

@@ -0,0 +1,10 @@
+require "appsignal"
+require "capistrano/version"
+
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION) >= Gem::Version.new(3)
+  # Capistrano 3+
+  load File.expand_path("../integrations/capistrano/appsignal.cap", __FILE__)
+else
+  # Capistrano 2
+  require "appsignal/integrations/capistrano/capistrano_2_tasks"
+end

data/lib/appsignal/cli.rb

@@ -0,0 +1,108 @@
+require "optparse"
+require "logger"
+require "appsignal"
+require "appsignal/cli/helpers"
+require "appsignal/cli/demo"
+require "appsignal/cli/diagnose"
+require "appsignal/cli/install"
+require "appsignal/cli/notify_of_deploy"
+
+module Appsignal
+  # @api private
+  class CLI
+    AVAILABLE_COMMANDS = %w[demo diagnose install notify_of_deploy].freeze
+
+    class << self
+      attr_accessor :options
+
+      def run(argv = ARGV)
+        @options = {}
+        global = global_option_parser
+        commands = command_option_parser
+        global.order!(argv)
+        command = argv.shift
+        if command
+          if AVAILABLE_COMMANDS.include?(command)
+            commands[command].parse!(argv)
+            case command.to_sym
+            when :demo
+              Appsignal::CLI::Demo.run(options)
+            when :diagnose
+              Appsignal::CLI::Diagnose.run(options)
+            when :install
+              Appsignal::CLI::Install.run(argv.shift)
+            when :notify_of_deploy
+              Appsignal::CLI::NotifyOfDeploy.run(options)
+            end
+          else
+            puts "Command '#{command}' does not exist, run appsignal -h to "\
+              "see the help"
+            exit(1)
+          end
+        else
+          # Print help
+          puts global
+          exit(0)
+        end
+      end
+
+      def global_option_parser
+        OptionParser.new do |o|
+          o.banner = "Usage: appsignal <command> [options]"
+
+          o.on "-v", "--version", "Print version and exit" do |_arg|
+            puts "AppSignal #{Appsignal::VERSION}"
+            exit(0)
+          end
+
+          o.on "-h", "--help", "Show help and exit" do
+            puts o
+            exit(0)
+          end
+
+          o.separator ""
+          o.separator "Available commands: #{AVAILABLE_COMMANDS.join(", ")}"
+        end
+      end
+
+      def command_option_parser
+        {
+          "demo" => OptionParser.new do |o|
+            o.banner = "Usage: appsignal demo [options]"
+
+            o.on "--environment=<app_env>", "The environment to demo" do |arg|
+              options[:environment] = arg
+            end
+          end,
+          "diagnose" => OptionParser.new do |o|
+            o.banner = "Usage: appsignal diagnose [options]"
+
+            o.on "--environment=<app_env>", "The environment to diagnose" do |arg|
+              options[:environment] = arg
+            end
+          end,
+          "install" => OptionParser.new,
+          "notify_of_deploy" => OptionParser.new do |o|
+            o.banner = "Usage: appsignal notify_of_deploy [options]"
+
+            o.on "--revision=<revision>", "The revision you're deploying" do |arg|
+              options[:revision] = arg
+            end
+
+            o.on "--user=<user>", "The name of the user that's deploying" do |arg|
+              options[:user] = arg
+            end
+
+            o.on "--environment=<app_env>", "The environment you're deploying to" do |arg|
+              options[:environment] = arg
+            end
+
+            o.on "--name=<name>", "The name of the app (optional)" do |arg|
+              options[:name] = arg
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/appsignal/cli/demo.rb

@@ -0,0 +1,63 @@
+require "appsignal/demo"
+
+module Appsignal
+  class CLI
+    # Command line tool for sending demonstration samples to AppSignal.com
+    #
+    # This command line tool is useful when testing AppSignal on a system and
+    # validating the local configuration. It tests if the installation of
+    # AppSignal has succeeded and if the AppSignal agent is able to run on the
+    # machine's architecture and communicate with the AppSignal servers.
+    #
+    # The same test is also run during installation with
+    # {Appsignal::CLI::Install}.
+    #
+    # ## Exit codes
+    #
+    # - Exits with status code `0` if the demo command has finished.
+    # - Exits with status code `1` if the demo command failed to finished.
+    #
+    # @example On the command line in your project
+    #   appsignal demo
+    #
+    # @example With a specific environment
+    #   appsignal demo --environment=production
+    #
+    # @example Standalone run
+    #   gem install appsignal
+    #   export APPSIGNAL_APP_NAME="My test app"
+    #   export APPSIGNAL_APP_ENV="test"
+    #   export APPSIGNAL_PUSH_API_KEY="xxxx-xxxx-xxxx-xxxx"
+    #   appsignal demo
+    #
+    # @since 2.0.0
+    # @see Appsignal::Demo
+    # @see Appsignal::CLI::Install
+    # @see http://docs.appsignal.com/ruby/command-line/demo.html
+    #   AppSignal demo documentation
+    # @see http://docs.appsignal.com/support/debugging.html
+    #   Debugging AppSignal guide
+    # @api private
+    class Demo
+      class << self
+        # @param options [Hash]
+        # @option options :environment [String] environment to load
+        #   configuration for.
+        # @return [void]
+        def run(options = {})
+          ENV["APPSIGNAL_APP_ENV"] = options[:environment] if options[:environment]
+
+          puts "Sending demonstration sample data..."
+          if Appsignal::Demo.transmit
+            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."
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/cli/diagnose.rb

@@ -0,0 +1,500 @@
+require "rbconfig"
+require "bundler/cli"
+require "bundler/cli/common"
+require "etc"
+
+module Appsignal
+  class CLI
+    # Command line tool to run diagnostics on your project.
+    #
+    # This command line tool is useful when testing AppSignal on a system and
+    # validating the local configuration. It outputs useful information to
+    # debug issues and it checks if AppSignal agent is able to run on the
+    # machine's architecture and communicate with the AppSignal servers.
+    #
+    # This diagnostic tool outputs the following:
+    # - if AppSignal can run on the host system.
+    # - if the configuration is valid and active.
+    # - if the Push API key is present and valid (internet connection required).
+    # - if the required system paths exist and are writable.
+    # - outputs AppSignal version information.
+    # - outputs information about the host system and Ruby.
+    # - outputs last lines from the available log files.
+    #
+    # ## Exit codes
+    #
+    # - Exits with status code `0` if the diagnose command has finished.
+    # - Exits with status code `1` if the diagnose command failed to finished.
+    #
+    # @example On the command line in your project
+    #   appsignal diagnose
+    #
+    # @example With a specific environment
+    #   appsignal diagnose --environment=production
+    #
+    # @see http://docs.appsignal.com/support/debugging.html Debugging AppSignal
+    # @see http://docs.appsignal.com/ruby/command-line/diagnose.html
+    #   AppSignal diagnose documentation
+    # @since 1.1.0
+    class Diagnose
+      extend CLI::Helpers
+
+      DIAGNOSE_ENDPOINT = "https://appsignal.com/diag".freeze
+
+      module Data
+        def data
+          @data ||= Hash.new { |hash, key| hash[key] = {} }
+        end
+
+        def data_section(key)
+          @section = key
+          yield
+          @section = nil
+        end
+
+        def current_section
+          @section
+        end
+
+        def save(key, value)
+          data[current_section][key] = value
+        end
+      end
+      extend Data
+
+      class << self
+        # @param options [Hash]
+        # @option options :environment [String] environment to load
+        #   configuration for.
+        # @return [void]
+        # @api private
+        def run(options = {})
+          $stdout.sync = true
+          header
+          empty_line
+
+          library_information
+          empty_line
+
+          host_information
+          empty_line
+
+          configure_appsignal(options)
+          run_agent_diagnose_mode
+          empty_line
+
+          config
+          empty_line
+
+          check_api_key
+          empty_line
+
+          paths_section
+          empty_line
+
+          log_files
+
+          transmit_report_to_appsignal if send_report_to_appsignal?
+        end
+
+        private
+
+        def send_report_to_appsignal?
+          puts "\nDiagnostics report"
+          puts "  Do you want to send this diagnostics report to AppSignal?"
+          puts "  If you share this diagnostics report you will be given\n" \
+            "  a support token you can use to refer to your diagnotics \n" \
+            "  report when you contact us at support@appsignal.com\n\n"
+          send_diagnostics = yes_or_no(
+            "  Send diagnostics report to AppSignal? (Y/n): ",
+            :default => "y"
+          )
+          unless send_diagnostics
+            puts "  Not sending diagnostics information to AppSignal."
+            return false
+          end
+          true
+        end
+
+        def transmit_report_to_appsignal
+          puts "\n  Transmitting diagnostics report"
+          transmitter = Transmitter.new(
+            DIAGNOSE_ENDPOINT,
+            Appsignal.config
+          )
+          response = transmitter.transmit(:diagnose => data)
+
+          unless response.code == "200"
+            puts "  Error: Something went wrong while submitting the report "\
+              "to AppSignal."
+            puts "  Response code: #{response.code}"
+            puts "  Response body:\n#{response.body}"
+            return
+          end
+
+          puts "  Please email us at support@appsignal.com with the following"
+          puts "  support token."
+          begin
+            response_data = JSON.parse(response.body)
+            puts "  Your support token: #{response_data["token"]}"
+          rescue JSON::ParserError
+            puts "  Error: Couldn't decode server response."
+            puts "  #{response.body}"
+          end
+        end
+
+        def puts_and_save(key, label, value)
+          save key, value
+          puts_value label, value
+        end
+
+        def puts_value(label, value, options = {})
+          options[:level] ||= 1
+          puts "#{"  " * options[:level]}#{label}: #{value}"
+        end
+
+        def configure_appsignal(options)
+          current_path = Dir.pwd
+          initial_config = {}
+          if rails_app?
+            data[:app][:rails] = true
+            current_path = Rails.root
+            initial_config[:name] = Rails.application.class.parent_name
+            initial_config[:log_path] = current_path.join("log")
+          end
+
+          Appsignal.config = Appsignal::Config.new(
+            current_path,
+            options[:environment],
+            initial_config
+          )
+          Appsignal.config.write_to_environment
+        end
+
+        def run_agent_diagnose_mode
+          puts "Agent diagnostics"
+          unless Appsignal.extension_loaded?
+            puts "  Extension is not loaded. No agent report created."
+            return
+          end
+
+          ENV["_APPSIGNAL_DIAGNOSE"] = "true"
+          diagnostics_report_string = Appsignal::Extension.diagnose
+          ENV.delete("_APPSIGNAL_DIAGNOSE")
+
+          begin
+            report = JSON.parse(diagnostics_report_string)
+            data[:agent] = report
+            print_agent_report(report)
+          rescue JSON::ParserError => error
+            puts "  Error while parsing agent diagnostics report:"
+            puts "    Error: #{error}"
+            puts "    Output: #{diagnostics_report_string}"
+            data[:agent] = {
+              :error => error,
+              :output => diagnostics_report_string.split("\n")
+            }
+          end
+        end
+
+        def print_agent_report(report)
+          if report["error"]
+            puts "  Error: #{report["error"]}"
+            return
+          end
+
+          agent_diagnostic_test_definition.each do |part, categories|
+            categories.each do |category, tests|
+              tests.each do |test_name, test_definition|
+                test_report = report
+                  .fetch(part, {})
+                  .fetch(category, {})
+                  .fetch(test_name, {})
+
+                print_agent_test(test_definition, test_report)
+              end
+            end
+          end
+        end
+
+        def print_agent_test(definition, test)
+          value = test["result"]
+          error = test["error"]
+          output = test["output"]
+
+          print "  #{definition[:label]}: "
+          display_value = definition[:values][value]
+          print display_value.nil? ? "-" : display_value
+          print "\n    Error: #{error}" if error
+          print "\n    Output: #{output}" if output
+          print "\n"
+        end
+
+        def agent_diagnostic_test_definition
+          {
+            "extension" => {
+              "config" => {
+                "valid" => {
+                  :label => "Extension config",
+                  :values => { true => "valid", false => "invalid" }
+                }
+              }
+            },
+            "agent" => {
+              "boot" => {
+                "started" => {
+                  :label => "Agent started",
+                  :values => { true => "started", false => "not started" }
+                }
+              },
+              "config" => {
+                "valid" => {
+                  :label => "Agent config",
+                  :values => { true => "valid", false => "invalid" }
+                }
+              },
+              "logger" => {
+                "started" => {
+                  :label => "Agent logger",
+                  :values => { true => "started", false => "not started" }
+                }
+              },
+              "lock_path" => {
+                "created" => {
+                  :label => "Agent lock path",
+                  :values => { true => "writable", false => "not writable" }
+                }
+              }
+            }
+          }
+        end
+
+        def header
+          puts "AppSignal diagnose"
+          puts "=" * 80
+          puts "Use this information to debug your configuration."
+          puts "More information is available on the documentation site."
+          puts "http://docs.appsignal.com/"
+          puts "Send this output to support@appsignal.com if you need help."
+          puts "=" * 80
+        end
+
+        def library_information
+          puts "AppSignal library"
+          data_section :library do
+            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 :package_install_path, "Gem install path", gem_path
+            puts_and_save :extension_loaded, "Extension loaded", Appsignal.extension_loaded
+          end
+        end
+
+        def host_information
+          rbconfig = RbConfig::CONFIG
+          puts "Host information"
+          data_section :host do
+            puts_and_save :architecture, "Architecture", rbconfig["host_cpu"]
+
+            os_label = os = rbconfig["host_os"]
+            os_label = "#{os} (Microsoft Windows is not supported.)" if Gem.win_platform?
+            save :os, os
+            puts_value "Operating System", os_label
+
+            puts_and_save :language_version, "Ruby version",
+              "#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"
+
+            puts_value "Heroku", "true" if Appsignal::System.heroku?
+            save :heroku, Appsignal::System.heroku?
+
+            save :root, Process.uid.zero?
+            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?
+          end
+        end
+
+        def config
+          puts "Configuration"
+          data_section :config do
+            puts_environment
+
+            Appsignal.config.config_hash.each do |key, value|
+              puts_and_save key, key, value
+            end
+          end
+        end
+
+        def puts_environment
+          env = Appsignal.config.env
+          puts_and_save :env, "Environment", env
+
+          return unless env == ""
+          puts "    Warning: No environment set, no config loaded!"
+          puts "    Please make sure appsignal diagnose is run within your "
+          puts "    project directory with an environment."
+          puts "      appsignal diagnose --environment=production"
+        end
+
+        def paths_section
+          puts "Paths"
+          data[:process] = process_user
+          data_section :paths do
+            appsignal_paths.each do |name, path|
+              path_info = {
+                :path => path,
+                :configured => !path.nil?,
+                :exists => false,
+                :writable => false
+              }
+              save name, path_info
+
+              puts_value name, path.to_s.inspect
+
+              unless path_info[:configured]
+                puts_value "Configured?", "false", :level => 2
+                next
+              end
+              unless File.exist?(path)
+                puts_value "Exists?", "false", :level => 2
+                next
+              end
+
+              path_info[:exists] = true
+              path_info[:writable] = File.writable?(path)
+              puts_value "Writable?", path_info[:writable], :level => 2
+
+              file_owner = path_ownership(path)
+              path_info[:ownership] = file_owner
+              save name, path_info
+
+              owned = process_user[:uid] == file_owner[:uid]
+              owner = "#{owned} " \
+                "(file: #{file_owner[:user]}:#{file_owner[:uid]}, " \
+                "process: #{process_user[:user]}:#{process_user[:uid]})"
+              puts_value "Ownership?", owner, :level => 2
+            end
+          end
+        end
+
+        def path_ownership(path)
+          file_uid = File.stat(path).uid
+          {
+            :uid => file_uid,
+            :user => username_for_uid(file_uid)
+          }
+        end
+
+        def process_user
+          return @process_user if defined?(@process_user)
+
+          process_uid = Process.uid
+          @process_user = {
+            :uid => process_uid,
+            :user => username_for_uid(process_uid)
+          }
+        end
+
+        def appsignal_paths
+          config = Appsignal.config
+          log_file_path = config.log_file_path
+          {
+            :working_dir => Dir.pwd,
+            :root_path => config.root_path,
+            :log_dir_path => log_file_path ? File.dirname(log_file_path) : "",
+            :log_file_path => log_file_path
+          }
+        end
+
+        def check_api_key
+          puts "Validation"
+          data_section :validation do
+            auth_check = ::Appsignal::AuthCheck.new(Appsignal.config)
+            status, error = auth_check.perform_with_result
+            result =
+              case status
+              when "200"
+                "valid"
+              when "401"
+                "invalid"
+              else
+                "Failed with status #{status}\n#{error.inspect}"
+              end
+            puts_and_save :push_api_key, "Validating Push API key", result
+          end
+        end
+
+        def log_files
+          puts "Log files"
+          data_section :logs do
+            install_log
+            empty_line
+            mkmf_log
+          end
+        end
+
+        def install_log
+          puts "  Extension install log"
+          filename = File.join("ext", "install.log")
+          log_info = log_file_info(File.join(gem_path, filename))
+          save filename, log_info
+          puts_log_file log_info
+        end
+
+        def mkmf_log
+          puts "  Makefile install log"
+          filename = File.join("ext", "mkmf.log")
+          log_info = log_file_info(File.join(gem_path, filename))
+          save filename, log_info
+          puts_log_file log_info
+        end
+
+        def log_file_info(log_file)
+          {
+            :path => log_file,
+            :exists => File.exist?(log_file)
+          }.tap do |info|
+            next unless info[:exists]
+            info[:content] = File.read(log_file).split("\n")
+          end
+        end
+
+        def puts_log_file(log_info)
+          puts_value "Path", log_info[:path].to_s.inspect, :level => 2
+          if log_info[:exists]
+            puts "    Contents:"
+            puts log_info[:content].join("\n")
+          else
+            puts "    File not found."
+          end
+        end
+
+        def username_for_uid(uid)
+          passwd_struct = Etc.getpwuid(uid)
+          return unless passwd_struct
+          passwd_struct.name
+        end
+
+        def empty_line
+          puts "\n"
+        end
+
+        def rails_app?
+          require "rails"
+          require File.expand_path(File.join(Dir.pwd, "config", "application.rb"))
+          true
+        rescue LoadError
+          false
+        end
+
+        def gem_path
+          @gem_path ||= \
+            Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
+        end
+      end
+    end
+  end
+end