appsignal 3.0.6-java → 3.0.10-java

data/lib/appsignal/cli/diagnose.rb

@@ -105,7 +105,6 @@ module Appsignal
           paths_report = Paths.new
           data[:paths] = paths_report.report
           print_paths_section(paths_report)
-          print_empty_line
 
           transmit_report_to_appsignal if send_report_to_appsignal?(options)
         end
@@ -327,6 +326,7 @@ module Appsignal
           puts "AppSignal library"
           data_section :library do
             save :language, "ruby"
+            puts_value "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 :extension_loaded, "Extension loaded", Appsignal.extension_loaded
@@ -399,6 +399,7 @@ module Appsignal
           puts "    Architecture: #{report["architecture"]}"
           puts "    Target: #{report["target"]}"
           puts "    Musl override: #{report["musl_override"]}"
+          puts "    Linux ARM override: #{report["linux_arm_override"]}"
           puts "    Library type: #{report["library_type"]}"
           puts "    Source: #{report["source"]}" if report["source"] != "remote"
           puts "    Dependencies: #{report["dependencies"]}"
@@ -416,7 +417,7 @@ module Appsignal
           rbconfig = RbConfig::CONFIG
           puts "Host information"
           data_section :host do
-            puts_and_save :architecture, "Architecture", rbconfig["host_cpu"]
+            puts_and_save :architecture, "Architecture", Appsignal::System.agent_architecture
 
             os_label = os = rbconfig["host_os"]
             os_label = "#{os} (Microsoft Windows is not supported.)" if Gem.win_platform?
@@ -573,9 +574,13 @@ module Appsignal
             "(file: #{ownership[:user]}:#{ownership[:uid]}, " \
             "process: #{process_user[:user]}:#{process_user[:uid]})"
           puts_value "Ownership?", owner, :level => 2
-          return unless path.key?(:content)
-          puts "    Contents (last 10 lines):"
-          puts path[:content].last(10)
+
+          if path.key?(:content)
+            puts "    Contents (last 10 lines):"
+            puts path[:content].last(10)
+          else
+            print_empty_line
+          end
         end
 
         def print_empty_line

data/lib/appsignal/config.rb

@@ -290,6 +290,7 @@ module Appsignal
       ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]       = config_hash[:files_world_accessible].to_s
       ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]       = config_hash[:transaction_debug_mode].to_s
       ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]    = config_hash[:send_environment_metadata].to_s
+      ENV["_APPSIGNAL_ENABLE_STATSD"]                = "true"
       ENV["_APP_REVISION"]                           = config_hash[:revision].to_s
     end
 

data/lib/appsignal/hooks/puma.rb

@@ -11,23 +11,8 @@ module Appsignal
       end
 
       def install
-        if ::Puma.respond_to?(:stats) && !defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)
-          # Only install the minutely probe if a user isn't using our Puma
-          # plugin, which lives in `lib/puma/appsignal.rb`. This plugin defines
-          # the {APPSIGNAL_PUMA_PLUGIN_LOADED} constant.
-          #
-          # We prefer people use the AppSignal Puma plugin. This fallback is
-          # only there when users relied on our *magic* integration.
-          #
-          # Using the Puma plugin, the minutely probe thread will still run in
-          # Puma workers, for other non-Puma probes, but the Puma probe only
-          # runs in the Puma main process.
-          # For more information:
-          # https://docs.appsignal.com/ruby/integrations/puma.html
-          Appsignal::Minutely.probes.register :puma, ::Appsignal::Probes::PumaProbe
-        end
-
         return unless defined?(::Puma::Cluster)
+
         # For clustered mode with multiple workers
         ::Puma::Cluster.send(:prepend, Module.new do
           def stop_workers

data/lib/appsignal/probes.rb

@@ -3,5 +3,4 @@ module Appsignal
   end
 end
 
-require "appsignal/probes/puma"
 require "appsignal/probes/sidekiq"

data/lib/appsignal/system.rb

@@ -8,6 +8,7 @@ module Appsignal
   # @api private
   module System
     LINUX_TARGET = "linux".freeze
+    LINUX_ARM_ARCHITECTURE = "aarch64".freeze
     MUSL_TARGET = "linux-musl".freeze
     FREEBSD_TARGET = "freebsd".freeze
     GEM_EXT_PATH = File.expand_path("../../../ext", __FILE__).freeze
@@ -18,15 +19,18 @@ module Appsignal
 
     # Detect agent and extension platform build
     #
-    # Used by `ext/extconf.rb` to select which build it should download and
+    # Used by `ext/*` to select which build it should download and
     # install.
     #
-    # Use `export APPSIGNAL_BUILD_FOR_MUSL=1` if the detection doesn't work
-    # and to force selection of the musl build.
+    # - Use `export APPSIGNAL_BUILD_FOR_MUSL=1` if the detection doesn't work
+    #   and to force selection of the musl build.
+    # - Use `export APPSIGNAL_BUILD_FOR_LINUX_ARM=1` to enable the experimental
+    #   Linux ARM build.
     #
     # @api private
     # @return [String]
     def self.agent_platform
+      return LINUX_TARGET if force_linux_arm_build?
       return MUSL_TARGET if force_musl_build?
 
       host_os = RbConfig::CONFIG["host_os"].downcase
@@ -53,6 +57,22 @@ module Appsignal
       local_os
     end
 
+    # Detect agent and extension architecture build
+    #
+    # Used by the `ext/*` tasks to select which architecture build it should download and install.
+    #
+    # - Use `export APPSIGNAL_BUILD_FOR_LINUX_ARM=1` to enable the experimental
+    #   Linux ARM build.
+    #
+    # @api private
+    # @return [String]
+    def self.agent_architecture
+      return LINUX_ARM_ARCHITECTURE if force_linux_arm_build?
+
+      # Fallback on the Ruby
+      RbConfig::CONFIG["host_cpu"]
+    end
+
     # Returns whether or not the musl build was forced by the user.
     #
     # @api private
@@ -60,6 +80,13 @@ module Appsignal
       %w[true 1].include?(ENV["APPSIGNAL_BUILD_FOR_MUSL"])
     end
 
+    # Returns whether or not the linux ARM build was selected by the user.
+    #
+    # @api private
+    def self.force_linux_arm_build?
+      %w[true 1].include?(ENV["APPSIGNAL_BUILD_FOR_LINUX_ARM"])
+    end
+
     # @api private
     def self.versionify(version)
       Gem::Version.new(version)

data/lib/appsignal/transaction.rb

@@ -526,7 +526,7 @@ module Appsignal
     end
 
     def cleaned_backtrace(backtrace)
-      if defined?(::Rails) && backtrace
+      if defined?(::Rails) && Rails.respond_to?(:backtrace_cleaner) && backtrace
         ::Rails.backtrace_cleaner.clean(backtrace, nil)
       else
         backtrace

data/lib/appsignal/version.rb

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

data/lib/puma/plugin/appsignal.rb

@@ -1,27 +1,156 @@
-APPSIGNAL_PUMA_PLUGIN_LOADED = true
+# frozen_string_literal: true
+
+require "json"
 
 # AppSignal Puma plugin
 #
-# This plugin ensures the minutely probe thread is started with the Puma
-# minutely probe in the Puma master process.
-#
-# The constant {APPSIGNAL_PUMA_PLUGIN_LOADED} is here to mark the Plugin as
-# loaded by the rest of the AppSignal gem. This ensures that the Puma minutely
-# probe is not also started in every Puma workers, which was the old behavior.
-# See {Appsignal::Hooks::PumaHook#install} for more information.
+# This plugin ensures Puma metrics are sent to the AppSignal agent using StatsD.
 #
 # For even more information:
 # https://docs.appsignal.com/ruby/integrations/puma.html
-Puma::Plugin.create do
-  def start(launcher = nil)
-    launcher.events.on_booted do
-      require "appsignal"
-      if ::Puma.respond_to?(:stats)
-        require "appsignal/probes/puma"
-        Appsignal::Minutely.probes.register :puma, Appsignal::Probes::PumaProbe
+Puma::Plugin.create do # rubocop:disable Metrics/BlockLength
+  def start(launcher)
+    @launcher = launcher
+    @launcher.events.debug "AppSignal: Puma plugin start."
+    in_background do
+      @launcher.events.debug "AppSignal: Start Puma stats collection loop."
+      plugin = AppsignalPumaPlugin.new
+
+      loop do
+        begin
+          # Implement similar behavior to minutely probes.
+          # Initial sleep to wait until the app is fully initalized.
+          # Then loop every 60 seconds and collect the Puma stats as AppSignal
+          # metrics.
+          sleep sleep_time
+
+          @launcher.events.debug "AppSignal: Collecting Puma stats."
+          stats = fetch_puma_stats
+          if stats
+            plugin.call(stats)
+          else
+            @launcher.events.log "AppSignal: No Puma stats to report."
+          end
+        rescue StandardError => error
+          log_error "Error while processing metrics.", error
+        end
       end
-      Appsignal.start
-      Appsignal.start_logger
+    end
+  end
+
+  private
+
+  def sleep_time
+    60 # seconds
+  end
+
+  def log_error(message, error)
+    @launcher.events.log "AppSignal: #{message}\n" \
+      "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+  end
+
+  def fetch_puma_stats
+    if Puma.respond_to? :stats_hash # Puma >= 5.0.0
+      Puma.stats_hash
+    elsif Puma.respond_to? :stats # Puma < 5.0.0
+      # Puma.stats_hash returns symbolized keys as well
+      JSON.parse Puma.stats, :symbolize_names => true
+    end
+  rescue StandardError => error
+    log_error "Error while parsing Puma stats.", error
+    nil
+  end
+end
+
+# AppsignalPumaPlugin
+#
+# Class to handle the logic of translating the Puma stats to AppSignal metrics.
+#
+# @api private
+class AppsignalPumaPlugin
+  def initialize
+    @hostname = fetch_hostname
+    @statsd = Statsd.new
+  end
+
+  def call(stats)
+    counts = {}
+    count_keys = [:backlog, :running, :pool_capacity, :max_threads]
+
+    if stats[:worker_status] # Clustered mode - Multiple workers
+      stats[:worker_status].each do |worker|
+        stat = worker[:last_status]
+        count_keys.each do |key|
+          count_if_present counts, key, stat
+        end
+      end
+
+      gauge(:workers, stats[:workers], :type => :count)
+      gauge(:workers, stats[:booted_workers], :type => :booted)
+      gauge(:workers, stats[:old_workers], :type => :old)
+    else # Single mode - Single worker
+      count_keys.each do |key|
+        count_if_present counts, key, stats
+      end
+    end
+
+    gauge(:connection_backlog, counts[:backlog]) if counts[:backlog]
+    gauge(:pool_capacity, counts[:pool_capacity]) if counts[:pool_capacity]
+    gauge(:threads, counts[:running], :type => :running) if counts[:running]
+    gauge(:threads, counts[:max_threads], :type => :max) if counts[:max_threads]
+  end
+
+  private
+
+  attr_reader :hostname
+
+  def fetch_hostname
+    # Configure hostname as reported for the Puma metrics with the
+    # APPSIGNAL_HOSTNAME environment variable.
+    env_hostname = ENV["APPSIGNAL_HOSTNAME"]
+    return env_hostname if env_hostname
+
+    # Auto detect hostname as fallback. May be inaccurate.
+    Socket.gethostname
+  end
+
+  def gauge(field, count, tags = {})
+    @statsd.gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
+  end
+
+  def count_if_present(counts, key, stats)
+    stat_value = stats[key]
+    return unless stat_value
+
+    counts[key] ||= 0
+    counts[key] += stat_value
+  end
+
+  class Statsd
+    def initialize
+      # StatsD server location as configured in AppSignal agent StatsD server.
+      @host = "127.0.0.1"
+      @port = 8125
+    end
+
+    def gauge(metric_name, value, tags)
+      send_metric "g", metric_name, value, tags
+    end
+
+    private
+
+    attr_reader :host, :port
+
+    def send_metric(type, metric_name, metric_value, tags_hash)
+      tags = tags_hash.map { |key, value| "#{key}:#{value}" }.join(",")
+      data = "#{metric_name}:#{metric_value}|#{type}|##{tags}"
+
+      # Open (and close) a new socket every time because we don't know when the
+      # plugin will exit and when to cleanly close the socket connection.
+      socket = UDPSocket.new
+      socket.send(data, 0, host, port)
+    ensure
+      socket && socket.close
     end
   end
 end

data/script/install_lintje

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -eu
+
+mkdir -p $HOME/bin
+cache_key=v1-lintje-$LINTJE_VERSION
+cache restore $cache_key
+
+# File exists and is executable
+if [ -x "$HOME/bin/lintje" ]; then
+  echo "Restored Lintje $LINTJE_VERSION from cache"
+else
+  echo "Downloading Lintje $LINTJE_VERSION"
+  curl -L \
+    https://github.com/tombruijn/lintje/releases/download/v$LINTJE_VERSION/x86_64-unknown-linux-gnu.tar.gz | \
+    tar -xz --directory $HOME/bin
+  cache store $cache_key $HOME/bin/lintje
+fi

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

@@ -270,9 +270,10 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           "build" => {
             "time" => kind_of(String),
             "package_path" => File.expand_path("../../../../../", __FILE__),
-            "architecture" => rbconfig["host_cpu"],
+            "architecture" => Appsignal::System.agent_architecture,
             "target" => Appsignal::System.agent_platform,
             "musl_override" => false,
+            "linux_arm_override" => false,
             "library_type" => jruby ? "dynamic" : "static",
             "source" => "remote",
             "dependencies" => kind_of(Hash),
@@ -301,9 +302,10 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           "  Checksum: verified",
           "Build details",
           "  Install time: 20",
-          "  Architecture: #{rbconfig["host_cpu"]}",
+          "  Architecture: #{Appsignal::System.agent_architecture}",
           "  Target: #{Appsignal::System.agent_platform}",
           "  Musl override: false",
+          "  Linux ARM override: false",
           "  Library type: #{jruby ? "dynamic" : "static"}",
           "  Dependencies: {",
           "  Flags: {",

data/spec/lib/appsignal/hooks/puma_spec.rb

@@ -35,29 +35,6 @@ describe Appsignal::Hooks::PumaHook do
           # Does not error on call
           Appsignal::Hooks::PumaHook.new.install
         end
-
-        context "with APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
-          before do
-            # Set in lib/puma/appsignal.rb
-            APPSIGNAL_PUMA_PLUGIN_LOADED = true
-          end
-          after { Object.send :remove_const, :APPSIGNAL_PUMA_PLUGIN_LOADED }
-
-          it "does not add the Puma minutely probe" do
-            Appsignal::Hooks::PumaHook.new.install
-            expect(Appsignal::Minutely.probes[:puma]).to be_nil
-          end
-        end
-
-        context "without APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
-          it "adds the Puma minutely probe" do
-            expect(defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)).to be_nil
-
-            Appsignal::Hooks::PumaHook.new.install
-            probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Probes::PumaProbe)
-          end
-        end
       end
 
       context "when in clustered mode" do
@@ -81,29 +58,6 @@ describe Appsignal::Hooks::PumaHook do
           cluster.stop_workers
           expect(cluster.instance_variable_get(:@called)).to be(true)
         end
-
-        context "with APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
-          before do
-            # Set in lib/puma/appsignal.rb
-            APPSIGNAL_PUMA_PLUGIN_LOADED = true
-          end
-          after { Object.send :remove_const, :APPSIGNAL_PUMA_PLUGIN_LOADED }
-
-          it "does not add the Puma minutely probe" do
-            Appsignal::Hooks::PumaHook.new.install
-            expect(Appsignal::Minutely.probes[:puma]).to be_nil
-          end
-        end
-
-        context "without APPSIGNAL_PUMA_PLUGIN_LOADED defined" do
-          it "adds the Puma minutely probe" do
-            expect(defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)).to be_nil
-
-            Appsignal::Hooks::PumaHook.new.install
-            probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Probes::PumaProbe)
-          end
-        end
       end
     end
   end