appsignal 2.8.0.alpha.1 → 2.8.0

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

@@ -0,0 +1,91 @@
+module Appsignal
+  class CLI
+    class Diagnose
+      class Paths
+        BYTES_TO_READ_FOR_FILES = 2 * 1024 * 1024 # 2 Mebibytes
+
+        def report
+          {}.tap do |hash|
+            paths.each do |filename, config|
+              hash[filename] = path_stat(config[:path])
+            end
+          end
+        end
+
+        def paths
+          @paths ||=
+            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 => {
+                  :label => "AppSignal gem path",
+                  :path => gem_path
+                },
+                :working_dir => {
+                  :label => "Current working directory",
+                  :path => Dir.pwd
+                },
+                :root_path => {
+                  :label => "Root path",
+                  :path => config.root_path
+                },
+                :log_dir_path => {
+                  :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)
+                },
+                "appsignal.log" => {
+                  :label => "AppSignal log",
+                  :path => log_file_path
+                }
+              }
+            end
+        end
+
+        private
+
+        def path_stat(path)
+          {
+            :path => path,
+            :exists => File.exist?(path)
+          }.tap do |info|
+            next unless info[:exists]
+            stat = File.stat(path)
+            info[:type] = stat.directory? ? "directory" : "file"
+            info[:mode] = format("%o", stat.mode)
+            info[:writable] = stat.writable?
+            path_uid = stat.uid
+            path_gid = stat.gid
+            info[:ownership] = {
+              :uid => path_uid,
+              :user => Utils.username_for_uid(path_uid),
+              :gid => path_gid,
+              :group => Utils.group_for_gid(path_gid)
+            }
+            if info[:type] == "file"
+              info[:content] = Utils.read_file_content(
+                path,
+                BYTES_TO_READ_FOR_FILES
+              ).split("\n")
+            end
+          end
+        end
+
+        def gem_path
+          @gem_path ||= \
+            Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Appsignal
+  class CLI
+    class Diagnose
+      class Utils
+        def self.username_for_uid(uid)
+          passwd_struct = Etc.getpwuid(uid)
+          return unless passwd_struct
+          passwd_struct.name
+        end
+
+        def self.group_for_gid(gid)
+          passwd_struct = Etc.getgrgid(gid)
+          return unless passwd_struct
+          passwd_struct.name
+        end
+
+        def self.read_file_content(path, bytes_to_read)
+          file_size = File.size(path)
+          if bytes_to_read > file_size
+            # When the file is smaller than the bytes_to_read
+            # Read the whole file
+            offset = 0
+            length = file_size
+          else
+            # When the file is smaller than the bytes_to_read
+            # Read the last X bytes_to_read
+            length = bytes_to_read
+            offset = file_size - bytes_to_read
+          end
+
+          IO.binread(path, length, offset)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/cli/install.rb

@@ -73,10 +73,10 @@ module Appsignal
         end
 
         def install_for_rails(config)
-          require File.expand_path(File.join(Dir.pwd, "config/application.rb"))
-
           puts "Installing for Ruby on Rails"
 
+          require File.expand_path(File.join(Dir.pwd, "config/application.rb"))
+
           config[:name] = Rails.application.class.parent_name
 
           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): ")

data/lib/appsignal/config.rb

@@ -8,6 +8,8 @@ require "tmpdir"
 
 module Appsignal
   class Config
+    include Appsignal::Utils::DeprecationMessage
+
     DEFAULT_CONFIG = {
       :debug                          => false,
       :log                            => "file",
@@ -82,27 +84,69 @@ module Appsignal
       :ignore_exceptions => :ignore_errors
     }.freeze
 
-    attr_reader :root_path, :env, :initial_config, :config_hash
+    # @attribute [r] system_config
+    #   Config detected on the system level.
+    #   Used in diagnose report.
+    #   @api private
+    #   @return [Hash]
+    # @!attribute [r] initial_config
+    #   Config detected on the system level.
+    #   Used in diagnose report.
+    #   @api private
+    #   @return [Hash]
+    # @!attribute [r] file_config
+    #   Config loaded from `config/appsignal.yml` config file.
+    #   Used in diagnose report.
+    #   @api private
+    #   @return [Hash]
+    # @!attribute [r] env_config
+    #   Config loaded from the system environment.
+    #   Used in diagnose report.
+    #   @api private
+    #   @return [Hash]
+    # @!attribute [r] config_hash
+    #   Config used by the AppSignal gem.
+    #   Combined Hash of the {system_config}, {initial_config}, {file_config},
+    #   {env_config} attributes.
+    #   @see #[]
+    #   @see #[]=
+    #   @api private
+    #   @return [Hash]
+
+    attr_reader :root_path, :env, :config_hash, :system_config,
+      :initial_config, :file_config, :env_config
     attr_accessor :logger
 
     def initialize(root_path, env, initial_config = {}, logger = Appsignal.logger)
       @root_path      = root_path
-      @env            = ENV.fetch("APPSIGNAL_APP_ENV".freeze, env.to_s)
-      @initial_config = initial_config
       @logger         = logger
       @valid          = false
       @config_hash    = Hash[DEFAULT_CONFIG]
+      env_loaded_from_initial = env.to_s
+      @env =
+        if ENV.key?("APPSIGNAL_APP_ENV".freeze)
+          env_loaded_from_env = ENV["APPSIGNAL_APP_ENV".freeze]
+        else
+          env_loaded_from_initial
+        end
 
       # Set config based on the system
-      detect_from_system
+      @system_config = detect_from_system
+      merge(system_config)
       # Initial config
-      merge(@config_hash, initial_config)
+      @initial_config = initial_config
+      merge(initial_config)
       # Load the config file if it exists
-      load_from_disk
+      @file_config = load_from_disk || {}
+      merge(file_config)
       # Load config from environment variables
-      load_from_environment
+      @env_config = load_from_environment
+      merge(env_config)
       # Validate that we have a correct config
       validate
+      # Track origin of env
+      @initial_config[:env] = env_loaded_from_initial if env_loaded_from_initial
+      @env_config[:env] = env_loaded_from_env if env_loaded_from_env
     end
 
     # @api private
@@ -166,7 +210,6 @@ module Appsignal
       ENV["_APPSIGNAL_IGNORE_ACTIONS"]               = config_hash[:ignore_actions].join(",")
       ENV["_APPSIGNAL_IGNORE_ERRORS"]                = config_hash[:ignore_errors].join(",")
       ENV["_APPSIGNAL_IGNORE_NAMESPACES"]            = config_hash[:ignore_namespaces].join(",")
-      ENV["_APPSIGNAL_SEND_PARAMS"]                  = config_hash[:send_params].to_s
       ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]         = config_hash[:running_in_container].to_s
       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]
@@ -208,10 +251,12 @@ module Appsignal
     end
 
     def detect_from_system
-      config_hash[:log] = "stdout" if Appsignal::System.heroku?
+      {}.tap do |hash|
+        hash[:log] = "stdout" if Appsignal::System.heroku?
 
-      # Make active by default if APPSIGNAL_PUSH_API_KEY is present
-      config_hash[:active] = true if ENV["APPSIGNAL_PUSH_API_KEY"]
+        # Make active by default if APPSIGNAL_PUSH_API_KEY is present
+        hash[:active] = true if ENV["APPSIGNAL_PUSH_API_KEY"]
+      end
     end
 
     def load_from_disk
@@ -225,11 +270,10 @@ module Appsignal
             hash[key.to_sym] = value # convert keys to symbols
           end
 
-        config_for_this_env = maintain_backwards_compatibility(config_for_this_env)
-
-        merge(@config_hash, config_for_this_env)
+        maintain_backwards_compatibility(config_for_this_env)
       else
         @logger.error "Not loading from config file: config for '#{env}' not found"
+        nil
       end
     end
 
@@ -242,17 +286,21 @@ module Appsignal
         DEPRECATED_CONFIG_KEY_MAPPING.each do |old_key, new_key|
           old_config_value = config.delete(old_key)
           next unless old_config_value
-          logger.warn "Old configuration key found. Please update the "\
-            "'#{old_key}' to '#{new_key}'."
+          deprecation_message \
+            "Old configuration key found. Please update the "\
+            "'#{old_key}' to '#{new_key}'.",
+            logger
 
           next if config[new_key] # Skip if new key is already in use
           config[new_key] = old_config_value
         end
 
         if config.include?(:working_dir_path)
-          logger.warn "'working_dir_path' is deprecated, please use " \
-                      "'working_directory_path' instead and specify the " \
-                      "full path to the working directory"
+          deprecation_message \
+            "'working_dir_path' is deprecated, please use " \
+            "'working_directory_path' instead and specify the " \
+            "full path to the working directory",
+            logger
         end
       end
     end
@@ -292,15 +340,15 @@ module Appsignal
         config[ENV_TO_KEY_MAPPING[var]] = env_var.split(",")
       end
 
-      merge(@config_hash, config)
+      config
     end
 
-    def merge(original_config, new_config)
+    def merge(new_config)
       new_config.each do |key, value|
-        unless original_config[key].nil?
+        unless config_hash[key].nil?
           @logger.debug("Config key '#{key}' is being overwritten")
         end
-        original_config[key] = value
+        config_hash[key] = value
       end
     end
   end

data/lib/appsignal/event_formatter.rb

@@ -14,6 +14,8 @@ module Appsignal
   # @api private
   class EventFormatter
     class << self
+      include Appsignal::Utils::DeprecationMessage
+
       def formatters
         @@formatters ||= {}
       end
@@ -33,7 +35,7 @@ module Appsignal
         end
 
         if registered?(name, formatter)
-          Appsignal.logger.warn(
+          logger.warn(
             "Formatter for '#{name}' already registered, not registering "\
             "'#{formatter.name}'"
           )
@@ -82,19 +84,23 @@ module Appsignal
       rescue => ex
         formatter_classes.delete(name)
         formatters.delete(name)
-        Appsignal.logger.warn("'#{ex.message}' when initializing #{name} event formatter")
+        logger.warn("'#{ex.message}' when initializing #{name} event formatter")
       end
 
       def register_deprecated_formatter(name)
-        Appsignal.logger.warn(
+        deprecation_message \
           "Formatter for '#{name}' is using a deprecated registration " \
           "method. This event formatter will not be loaded. " \
           "Please update the formatter according to the documentation at: " \
-          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-        )
+          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html",
+          logger
 
         deprecated_formatter_classes[name] = self
       end
+
+      def logger
+        Appsignal.logger
+      end
     end
 
     # @api public

data/lib/appsignal/garbage_collection_profiler.rb

@@ -47,4 +47,15 @@ module Appsignal
       self.class.lock
     end
   end
+
+  # {Appsignal::NilGarbageCollectionProfiler} is a dummy profiler
+  # that always returns 0 as the total time.
+  # Used when we don't want any profile information
+  #
+  # @api private
+  class NilGarbageCollectionProfiler
+    def total_time
+      0
+    end
+  end
 end

data/lib/appsignal/system.rb

@@ -7,7 +7,9 @@ module Appsignal
   #
   # @api private
   module System
+    LINUX_TARGET = "linux".freeze
     MUSL_TARGET = "linux-musl".freeze
+    FREEBSD_TARGET = "freebsd".freeze
     GEM_EXT_PATH = File.expand_path("../../../ext", __FILE__).freeze
 
     def self.heroku?
@@ -45,12 +47,12 @@ module Appsignal
       host_os = RbConfig::CONFIG["host_os"].downcase
       local_os =
         case host_os
-        when /linux/
-          "linux"
+        when /#{LINUX_TARGET}/
+          LINUX_TARGET
         when /darwin/
           "darwin"
-        when /freebsd/
-          "freebsd"
+        when /#{FREEBSD_TARGET}/
+          FREEBSD_TARGET
         else
           host_os
         end

data/lib/appsignal/transaction.rb

@@ -53,7 +53,8 @@ module Appsignal
       end
 
       def garbage_collection_profiler
-        @garbage_collection_profiler ||= Appsignal::GarbageCollectionProfiler.new
+        @garbage_collection_profiler ||=
+          Appsignal.config[:enable_gc_instrumentation] ? Appsignal::GarbageCollectionProfiler.new : NilGarbageCollectionProfiler.new
       end
     end
 

data/lib/appsignal/utils.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "appsignal/utils/deprecation_message"
 require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"
 require "appsignal/utils/json"

data/lib/appsignal/utils/deprecation_message.rb

@@ -0,0 +1,10 @@
+module Appsignal
+  module Utils
+    module DeprecationMessage
+      def deprecation_message(message, logger)
+        $stdout.puts "appsignal WARNING: #{message}"
+        logger.warn message
+      end
+    end
+  end
+end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.8.0.alpha.1".freeze
+  VERSION = "2.8.0".freeze
 end

data/spec/lib/appsignal/cli/diagnose/utils_spec.rb

@@ -0,0 +1,37 @@
+require "appsignal/cli/diagnose/utils"
+
+describe Appsignal::CLI::Diagnose::Utils do
+  describe ".read_file_content" do
+    let(:path) { File.join(spec_system_tmp_dir, "test_file.txt") }
+    let(:bytes_to_read) { 100 }
+    subject { described_class.read_file_content(path, bytes_to_read) }
+    before do
+      File.open path, "w+" do |f|
+        f.write file_contents
+      end
+    end
+
+    context "when file is bigger than read size" do
+      let(:file_contents) do
+        "".tap do |s|
+          100.times do |i|
+            s << "line #{i}\n"
+          end
+        end
+      end
+
+      it "returns the last X bytes" do
+        is_expected
+          .to eq(file_contents[(file_contents.length - bytes_to_read)..file_contents.length])
+      end
+    end
+
+    context "when file is smaller than read size" do
+      let(:file_contents) { "line 1\n" }
+
+      it "returns the whole file content" do
+        is_expected.to eq(file_contents)
+      end
+    end
+  end
+end