appsignal 4.0.5 → 4.0.7

data/spec/lib/puma/appsignal_spec.rb

@@ -1,334 +0,0 @@
-RSpec.describe "Puma plugin" do
-  include WaitForHelper
-
-  class MockPumaLauncher
-    def log_writer
-      return @log_writer if defined?(@log_writer)
-
-      @log_writer = MockPumaLogWriter.new
-    end
-  end
-
-  class MockPumaLogWriter
-    attr_reader :logs
-
-    def initialize
-      @logs = []
-    end
-
-    def log(message)
-      @logs << [:log, message]
-    end
-
-    def debug(message)
-      @logs << [:debug, message]
-    end
-
-    def error(message)
-      @logs << [:error, message]
-    end
-  end
-
-  # StatsD server used for these tests.
-  # Open a UDPSocket and listen for messages sent by the AppSignal Puma plugin.
-  class StatsdServer
-    def initialize(statsd_port)
-      @statsd_port = statsd_port
-    end
-
-    def start
-      stop
-      @socket = UDPSocket.new
-      @socket.bind("127.0.0.1", @statsd_port)
-
-      loop do
-        # Listen for messages and track them on the messages Array.
-        packet = @socket.recvfrom(1024)
-        track_message packet.first
-      rescue Errno::EBADF
-        # Ignore error for JRuby 9.1.17.0 specifically, it doesn't appear to
-        # happen on 9.2.18.0. It doesn't break the tests themselves, ignoring
-        # this error. It's probably a timing issue where it tries to read
-        # from the socket after it's closed.
-      end
-    end
-
-    def stop
-      defined?(@socket) && @socket && @socket.close
-    ensure
-      @socket = nil
-    end
-
-    def messages
-      @messages ||= []
-    end
-
-    private
-
-    def track_message(message)
-      @messages_mutex ||= Mutex.new
-      @messages_mutex.synchronize { messages << message }
-    end
-  end
-
-  let(:probe) { MockProbe.new }
-  let(:launcher) { MockPumaLauncher.new }
-  let(:hostname) { Socket.gethostname }
-  let(:expected_default_tags) { { "hostname" => hostname } }
-  let(:stats_data) { { :backlog => 1 } }
-  before do
-    module Puma
-      def self.stats
-        JSON.dump(@_stats_data)
-      end
-
-      def self.stats_hash
-        @_stats_data
-      end
-
-      def self._set_stats=(data)
-        @_stats_data = data
-      end
-
-      class Plugin
-        class << self
-          attr_reader :appsignal_plugin
-
-          def create(&block)
-            @appsignal_plugin = Class.new(::Puma::Plugin)
-            @appsignal_plugin.class_eval(&block)
-          end
-        end
-
-        attr_reader :in_background_block
-
-        def in_background(&block)
-          @in_background_block = block
-        end
-      end
-    end
-    load File.expand_path("../lib/puma/plugin/appsignal.rb", APPSIGNAL_SPEC_DIR)
-  end
-  after do
-    Object.send(:remove_const, :Puma)
-    Object.send(:remove_const, :AppsignalPumaPlugin)
-  end
-
-  def run_plugin(stats_data, plugin, &block)
-    Puma._set_stats = stats_data
-    ENV["APPSIGNAL_STATSD_PORT"] = "8126"
-    @statsd = StatsdServer.new(ENV.fetch("APPSIGNAL_STATSD_PORT"))
-    @server_thread = Thread.new { @statsd.start }
-    @server_thread.abort_on_exception = true
-    @client_thread = Thread.new { start_plugin(plugin) }
-    @client_thread.abort_on_exception = true
-    wait_for(:puma_client_wait, &block)
-  ensure
-    ENV["APPSIGNAL_STATSD_PORT"] = nil
-    Puma._set_stats = nil
-    # Stop all threads in test and stop listening on the UDPSocket
-    @client_thread.kill if defined?(@client_thread) && @client_thread
-    @server_thread.kill if defined?(@server_thread) && @server_thread
-    @client_thread = nil
-    @server_thread = nil
-
-    @statsd.stop if defined?(@statsd) && @statsd
-    @statsd = nil
-  end
-
-  def appsignal_plugin
-    Puma::Plugin.appsignal_plugin
-  end
-
-  def start_plugin(plugin_class)
-    plugin = plugin_class.new
-    # Speed up test by not waiting for 60 seconds initial wait time and loop
-    # interval.
-    allow(plugin).to receive(:sleep_time).and_return(0.01)
-    plugin.start(launcher)
-    plugin.in_background_block.call
-  end
-
-  def logs
-    launcher.log_writer.logs
-  end
-
-  def messages
-    @statsd.messages.map do |message|
-      metric, type, tags_string = message.split("|")
-      metric_name, metric_value = metric.split(":")
-      tags = {}
-      tags_string[1..].split(",").each do |tag|
-        key, value = tag.split(":")
-        tags[key] = value
-      end
-      {
-        :name => metric_name,
-        :value => metric_value.to_i,
-        :type => type,
-        :tags => tags
-      }
-    end
-  end
-
-  def expect_gauge(metric_name, metric_value, tags_hash = {})
-    expect(messages).to include(
-      :name => "puma_#{metric_name}",
-      :value => metric_value,
-      :type => "g",
-      :tags => expected_default_tags.merge(tags_hash)
-    )
-  end
-
-  context "with multiple worker stats" do
-    let(:stats_data) do
-      {
-        :workers => 2,
-        :booted_workers => 2,
-        :old_workers => 0,
-        :worker_status => [
-          {
-            :last_status => {
-              :backlog => 0,
-              :running => 5,
-              :pool_capacity => 5,
-              :max_threads => 5
-            }
-          },
-          {
-            :last_status => {
-              :backlog => 0,
-              :running => 5,
-              :pool_capacity => 5,
-              :max_threads => 5
-            }
-          }
-        ]
-      }
-    end
-
-    it "collects puma stats as gauge metrics with the (summed) worker metrics" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect_gauge(:workers, 2, "type" => "count")
-        expect_gauge(:workers, 2, "type" => "booted")
-        expect_gauge(:workers, 0, "type" => "old")
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 10)
-        expect_gauge(:threads, 10, "type" => "running")
-        expect_gauge(:threads, 10, "type" => "max")
-      end
-    end
-  end
-
-  context "with single worker stats" do
-    let(:stats_data) do
-      {
-        :backlog => 0,
-        :running => 5,
-        :pool_capacity => 5,
-        :max_threads => 5
-      }
-    end
-
-    it "calls `puma_gauge` with the (summed) worker metrics" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 5)
-        expect_gauge(:threads, 5, "type" => "running")
-        expect_gauge(:threads, 5, "type" => "max")
-      end
-    end
-  end
-
-  context "when using APPSIGNAL_HOSTNAME" do
-    let(:hostname) { "my-host-name" }
-    before { ENV["APPSIGNAL_HOSTNAME"] = hostname }
-    after { ENV.delete("APPSIGNAL_HOSTNAME") }
-
-    it "reports the APPSIGNAL_HOSTNAME as the hostname tag value" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect_gauge(:connection_backlog, 1)
-      end
-    end
-  end
-
-  context "without Puma.stats_hash" do
-    before do
-      Puma.singleton_class.send(:remove_method, :stats_hash)
-    end
-
-    it "fetches metrics from Puma.stats instead" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect(logs).to_not include([kind_of(Symbol), "AppSignal: No Puma stats to report."])
-        expect_gauge(:connection_backlog, 1)
-      end
-    end
-  end
-
-  context "without Puma.stats and Puma.stats_hash" do
-    before do
-      Puma.singleton_class.send(:remove_method, :stats)
-      Puma.singleton_class.send(:remove_method, :stats_hash)
-    end
-
-    it "does not fetch metrics" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect(logs).to include([:debug, "AppSignal: No Puma stats to report."])
-        expect(messages).to be_empty
-      end
-    end
-  end
-
-  context "without running StatsD server" do
-    it "does nothing" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(logs).to_not include([:error, kind_of(String)])
-        expect(messages).to be_empty
-      end
-    end
-  end
-
-  context "with Puma < 6 Events class" do
-    class MockPumaEvents
-      attr_reader :logs
-
-      def initialize
-        @logs = []
-      end
-
-      def log(message)
-        @logs << [:log, message]
-      end
-
-      def debug(message)
-        @logs << [:debug, message]
-      end
-
-      def error(message)
-        @logs << [:error, message]
-      end
-    end
-
-    let(:launcher) do
-      Class.new do
-        def events
-          return @events if defined?(@events)
-
-          @events = MockPumaEvents.new
-        end
-      end.new
-    end
-    let(:stats_data) { { :max_threads => 5 } }
-
-    it "logs messages to the events class" do
-      run_plugin(stats_data, appsignal_plugin) do
-        expect(launcher.events.logs).to_not be_empty
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,173 +0,0 @@
-ENV["RAILS_ENV"] ||= "test"
-ENV["RACK_ENV"] ||= "test"
-ENV["PADRINO_ENV"] ||= "test"
-
-APPSIGNAL_SPEC_DIR = File.expand_path(__dir__)
-$LOAD_PATH.unshift(File.join(APPSIGNAL_SPEC_DIR, "support/stubs"))
-
-Bundler.require :default
-require "cgi"
-require "rack"
-require "rspec"
-require "timecop"
-require "webmock/rspec"
-
-Dir[File.join(APPSIGNAL_SPEC_DIR, "support", "helpers", "*.rb")].sort.each do |f|
-  require f
-end
-Dir[File.join(DirectoryHelper.support_dir, "mocks", "*.rb")].sort.each do |f|
-  require f
-end
-Dir[File.join(DirectoryHelper.support_dir, "matchers", "*.rb")].sort.each do |f|
-  require f
-end
-Dir[File.join(APPSIGNAL_SPEC_DIR, "support/shared_examples", "*.rb")].sort.each do |f|
-  require f
-end
-if DependencyHelper.rails_present?
-  require File.join(ConfigHelpers.rails_project_fixture_path, "config/application.rb")
-end
-if DependencyHelper.hanami2_present?
-  Dir[File.join(DirectoryHelper.support_dir, "hanami", "*.rb")].sort.each do |f|
-    require f
-  end
-end
-require "pry" if DependencyHelper.dependency_present?("pry")
-require "appsignal"
-# Include patches of AppSignal modules and classes to make test helpers
-# available.
-require File.join(DirectoryHelper.support_dir, "testing.rb")
-
-puts "Running specs in #{RUBY_VERSION} on #{RUBY_PLATFORM}\n\n"
-
-# Add way to clear subscribers between specs
-if defined?(ActiveSupport)
-  module ActiveSupport
-    module Notifications
-      class Fanout
-        def clear_subscribers
-          @subscribers.clear
-          @listeners_for.clear
-        end
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include DirectoryHelper
-  config.include StdStreamsHelper
-  config.include ConfigHelpers
-  config.include EnvHelpers
-  config.include TimeHelpers
-  config.include TransactionHelpers
-  config.include ApiRequestHelper
-  config.include SystemHelpers
-  config.include LogHelpers
-  config.include LoaderHelper
-  config.extend DependencyHelper
-
-  config.example_status_persistence_file_path = "spec/examples.txt"
-  config.fail_if_no_examples = true
-  config.exclude_pattern = "spec/integration/diagnose/**/*_spec.rb"
-  config.filter_run_excluding(
-    :extension_installation_failure => true,
-    :jruby => !DependencyHelper.running_jruby?
-  )
-  config.mock_with :rspec do |mocks|
-    mocks.syntax = :expect
-  end
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = :expect
-  end
-
-  def spec_system_tmp_dir
-    File.join(tmp_dir, "system-tmp")
-  end
-
-  config.before :context do
-    FileUtils.rm_rf(tmp_dir)
-    FileUtils.mkdir_p(spec_system_tmp_dir)
-  end
-
-  config.before do
-    Appsignal.clear!
-    Appsignal::Testing.clear!
-    Appsignal::Loaders.clear!
-    clear_current_transaction!
-    stop_minutely_probes
-    ENV["RAILS_ENV"] ||= "test"
-    ENV["RACK_ENV"] ||= "test"
-    ENV["PADRINO_ENV"] ||= "test"
-
-    # Clean environment
-    appsignal_key_prefixes = %w[APPSIGNAL_ _APPSIGNAL_]
-    env_keys = ENV.keys.select { |key| key.start_with?(*appsignal_key_prefixes) }
-    # Always unset the diagnose variable
-    # For normal Ruby this is unset in the diagnose task itself, but the JRuby
-    # bug requires us to unset it using the method below as well. It's not
-    # present in the ENV keys list because it's already cleared in Ruby itself
-    # in the diagnose task, so add it manually to the list of to-be cleaned up
-    # keys.
-    env_keys << "_APPSIGNAL_DIAGNOSE"
-    env_keys << "_TEST_APPSIGNAL_EXTENSION_FAILURE"
-    env_keys.each do |key|
-      # First set the ENV var to an empty string and then delete the key from
-      # the env. We set the env var to an empty string first as JRuby doesn't
-      # sync `delete` calls to extensions, making our extension think the env
-      # var is still set after calling `ENV.delete`. Setting it to an empty
-      # string will sort of unset it, our extension ignores env vars with an
-      # empty string as a value.
-      ENV[key] = ""
-      ENV.delete(key)
-    end
-
-    # Stub system_tmp_dir to something in the project dir for specs
-    allow(Appsignal::Config).to receive(:system_tmp_dir).and_return(spec_system_tmp_dir)
-
-    # Unsubscribe Rails error reporter if present to avoid it reporting errors
-    # multiple times through multiple subscriptions.
-    if defined?(Rails) && Rails.respond_to?(:error)
-      if Rails.error.respond_to?(:unsubscribe) # Future Rails version after 7.0.4.3
-        Rails.error.unsubscribe(Appsignal::Integrations::RailsErrorReporterSubscriber)
-      else
-        Rails.error.instance_variable_get(:@subscribers)
-          .delete(Appsignal::Integrations::RailsErrorReporterSubscriber)
-      end
-    end
-  end
-
-  # These tests are not run by default. They require a failed extension
-  # installation. See the `rake test:failure` task. If a test with this tag was
-  # run, run `rake extension:install` again to fix the extension installation
-  # before running other tests.
-  config.before :extension_installation_failure => true do
-    next unless Appsignal.extension_loaded?
-
-    raise "Extension is loaded, please run the following task and rerun the test." \
-      "\n\n    rake test:prepare_failure"
-  end
-
-  # Check to see if the extension is loaded before running the specs. If the
-  # extension is not loaded it can result in unexpected behavior.
-  config.before do |example|
-    next if Appsignal.extension_loaded?
-    next if example.metadata[:extension_installation_failure]
-
-    puts "\nWARNING: The AppSignal extension is not loaded, please run the " \
-      "following task and rerun the test." \
-      "\n\n    rake extension:install\n"
-  end
-
-  config.after do
-    stop_minutely_probes
-  end
-
-  config.after :context do
-    FileUtils.rm_f(File.join(project_fixture_path, "log/appsignal.log"))
-  end
-
-  def stop_minutely_probes
-    Appsignal::Probes.stop
-  end
-end

data/spec/support/fixtures/generated_config.yml

@@ -1,24 +0,0 @@
-default: &defaults
-  # Your push api key, it is possible to set this dynamically using ERB:
-  # push_api_key: "<%= ENV['APPSIGNAL_PUSH_API_KEY'] %>"
-  push_api_key: "my_app_key"
-
-  # Your app's name
-  name: "MyApp"
-
-  # The cuttoff point in ms above which a request is considered slow, default is 200
-  # slow_request_threshold: 200
-
-  # Actions that should not be monitored by AppSignal
-  # ignore_actions:
-  #   - ApplicationController#isup
-
-# Configuration per environment, leave out an environment or set active
-# to false to not push metrics for that environment.
-development:
-  <<: *defaults
-  active: true
-
-production:
-  <<: *defaults
-  active: true

data/spec/support/fixtures/projects/broken/config/appsignal.yml

@@ -1 +0,0 @@
-<%= ENV.fetch("I AM A KEY THAT DOES NOT EXIST") %>

data/spec/support/fixtures/projects/valid/config/appsignal.yml

@@ -1,57 +0,0 @@
-default: &defaults
-  push_api_key: "abc"
-  name: "TestApp"
-  enable_minutely_probes: false
-
-production:
-  <<: *defaults
-  active: true
-
-development:
-  <<: *defaults
-  active: true
-
-test:
-  <<: *defaults
-  endpoint: "http://localhost:3000"
-  log_level: debug
-  active: true
-
-old_config:
-  api_key: "def"
-  active: true
-  ignore_exceptions:
-    - StandardError
-  request_headers: [
-    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
-    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
-    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
-    "REQUEST_METHOD", "REQUEST_PATH", "SERVER_NAME", "SERVER_PORT",
-    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
-  ]
-
-old_config_mixed_with_new_config:
-  push_api_key: "ghi"
-  api_key: "def"
-  active: true
-  ignore_errors:
-    - NoMethodError
-  ignore_exceptions:
-    - StandardError
-  request_headers: [
-    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
-    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
-    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
-    "REQUEST_METHOD", "REQUEST_PATH", "SERVER_NAME", "SERVER_PORT",
-    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
-  ]
-
-rack_env:
-  <<: *defaults
-
-rails_env:
-  <<: *defaults
-
-inactive_env:
-  <<: *defaults
-  active: false

data/spec/support/fixtures/projects/valid_with_rails_app/config/application.rb

@@ -1,16 +0,0 @@
-require "rails"
-
-module MyApp
-  class Application < Rails::Application
-    config.active_support.deprecation = proc { |message, stack| }
-    config.eager_load = false
-
-    def self.initialize!
-      # Prevent errors about Rails being initialized more than once
-      return if defined?(@initialized)
-
-      super
-      @initialized = true
-    end
-  end
-end

data/spec/support/fixtures/projects/valid_with_rails_app/config/appsignal.yml

@@ -1,56 +0,0 @@
-default: &defaults
-  push_api_key: "abc"
-  name: "TestApp"
-  enable_minutely_probes: false
-
-production:
-  <<: *defaults
-  active: true
-
-development:
-  <<: *defaults
-  active: true
-
-test:
-  <<: *defaults
-  log_level: debug
-  active: true
-
-old_config:
-  api_key: "def"
-  active: true
-  ignore_exceptions:
-    - StandardError
-  request_headers: [
-    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
-    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
-    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
-    "REQUEST_METHOD", "REQUEST_PATH", "SERVER_NAME", "SERVER_PORT",
-    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
-  ]
-
-old_config_mixed_with_new_config:
-  push_api_key: "ghi"
-  api_key: "def"
-  active: true
-  ignore_errors:
-    - NoMethodError
-  ignore_exceptions:
-    - StandardError
-  request_headers: [
-    "HTTP_ACCEPT", "HTTP_ACCEPT_CHARSET", "HTTP_ACCEPT_ENCODING",
-    "HTTP_ACCEPT_LANGUAGE", "HTTP_CACHE_CONTROL", "HTTP_CONNECTION",
-    "CONTENT_LENGTH", "PATH_INFO", "HTTP_RANGE", "HTTP_REFERER",
-    "REQUEST_METHOD", "REQUEST_PATH", "SERVER_NAME", "SERVER_PORT",
-    "SERVER_PROTOCOL", "HTTP_USER_AGENT"
-  ]
-
-rack_env:
-  <<: *defaults
-
-rails_env:
-  <<: *defaults
-
-inactive_env:
-  <<: *defaults
-  active: false

data/spec/support/fixtures/projects/valid_with_rails_app/config/environment.rb

@@ -1,10 +0,0 @@
-# Load the Rails application.
-require_relative "application"
-
-# Initialize the Rails application.
-MyApp::Application.initialize!
-
-# Asserted from the diagnose spec
-Appsignal.configure do |config|
-  config.ignore_actions = ["Action from DSL"]
-end