appsignal 3.0.4 → 3.0.9

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.4".freeze
+  VERSION = "3.0.9".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/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/excon_spec.rb

@@ -0,0 +1,74 @@
+describe Appsignal::Hooks::ExconHook do
+  before :context do
+    start_agent
+  end
+
+  context "with Excon" do
+    before(:context) do
+      class Excon
+        def self.defaults
+          @defaults ||= {}
+        end
+      end
+      Appsignal::Hooks::ExconHook.new.install
+    end
+    after(:context) { Object.send(:remove_const, :Excon) }
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    describe "#install" do
+      it "adds the AppSignal instrumentor to Excon" do
+        expect(Excon.defaults[:instrumentor]).to eql(Appsignal::Integrations::ExconIntegration)
+      end
+    end
+
+    describe "instrumentation" do
+      let!(:transaction) do
+        Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+      end
+      around { |example| keep_transactions { example.run } }
+
+      it "instruments a http request" do
+        data = {
+          :host => "www.google.com",
+          :method => :get,
+          :scheme => "http"
+        }
+        Excon.defaults[:instrumentor].instrument("excon.request", data) {}
+
+        expect(transaction.to_h["events"]).to include(
+          hash_including(
+            "name" => "request.excon",
+            "title" => "GET http://www.google.com",
+            "body" => ""
+          )
+        )
+      end
+
+      it "instruments a http response" do
+        data = { :host => "www.google.com" }
+        Excon.defaults[:instrumentor].instrument("excon.response", data) {}
+
+        expect(transaction.to_h["events"]).to include(
+          hash_including(
+            "name" => "response.excon",
+            "title" => "www.google.com",
+            "body" => ""
+          )
+        )
+      end
+    end
+  end
+
+  context "without Excon" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

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

@@ -33,16 +33,17 @@ describe Appsignal::Hooks::RedisHook do
 
           context "instrumentation" do
             before do
+              start_agent
               # Stub Redis::Client class so that it doesn't perform an actual
               # Redis query. This class will be included (prepended) with the
               # AppSignal Redis integration.
               stub_const("Redis::Client", Class.new do
                 def id
-                  :stub_id
+                  "stub_id"
                 end
 
-                def process(_commands)
-                  :stub_process
+                def write(_commands)
+                  "stub_write"
                 end
               end)
               # Load the integration again for the stubbed Redis::Client class.
@@ -50,17 +51,40 @@ describe Appsignal::Hooks::RedisHook do
               # track if it was installed already or not.
               Appsignal::Hooks::RedisHook.new.install
             end
+            let!(:transaction) do
+              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+            end
+            around { |example| keep_transactions { example.run } }
 
             it "instrument a redis call" do
-              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-              expect(Appsignal::Transaction.current).to receive(:start_event)
-                .at_least(:once)
-              expect(Appsignal::Transaction.current).to receive(:finish_event)
-                .at_least(:once)
-                .with("query.redis", :stub_id, "get ?", 0)
+              client = Redis::Client.new
+              expect(client.write([:get, "key"])).to eql("stub_write")
 
+              transaction_hash = transaction.to_h
+              expect(transaction_hash["events"]).to include(
+                hash_including(
+                  "name" => "query.redis",
+                  "body" => "get ?",
+                  "title" => "stub_id"
+                )
+              )
+            end
+
+            it "instrument a redis script call" do
               client = Redis::Client.new
-              expect(client.process([[:get, "key"]])).to eql(:stub_process)
+              script = "return redis.call('set',KEYS[1],ARGV[1])"
+              keys = ["foo"]
+              argv = ["bar"]
+              expect(client.write([:eval, script, keys.size, keys, argv])).to eql("stub_write")
+
+              transaction_hash = transaction.to_h
+              expect(transaction_hash["events"]).to include(
+                hash_including(
+                  "name" => "query.redis",
+                  "body" => "#{script} ? ?",
+                  "title" => "stub_id"
+                )
+              )
             end
           end
         end