appsignal 4.0.5 → 4.0.7

data/spec/support/hanami/hanami_app.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami"
-require "hanami/action"
-
-module HanamiApp
-  class App < Hanami::App
-  end
-
-  class Routes < Hanami::Routes
-    get "/books", :to => "books.index"
-  end
-
-  module Actions
-    module Books
-      class Index < Hanami::Action
-        def handle(_request, response)
-          response.body = "YOU REQUESTED BOOKS!"
-        end
-      end
-
-      class Error < Hanami::Action
-        def handle(_request, _response)
-          raise ExampleException, "exception message"
-        end
-      end
-    end
-  end
-end

data/spec/support/helpers/action_mailer_helpers.rb

@@ -1,25 +0,0 @@
-module ActionMailerHelpers
-  def perform_action_mailer(mailer, method, args = nil)
-    if DependencyHelper.rails_version >= Gem::Version.new("5.2.0")
-      case args
-      when Array
-        mailer.send(method, *args).deliver_later
-      when Hash
-        mailer.with(args).send(method).deliver_later
-      when NilClass
-        mailer.send(method).deliver_later
-      else
-        raise "Unknown scenario for arguments: #{args}"
-      end
-    else
-      # Rails 5.1 and lower
-      mailer_object =
-        if args
-          mailer.send(method, *args)
-        else
-          mailer.send(method)
-        end
-      mailer_object.deliver_later
-    end
-  end
-end

data/spec/support/helpers/activejob_helpers.rb

@@ -1,27 +0,0 @@
-module ActiveJobHelpers
-  def active_job_args_wrapper(args: [], params: nil)
-    if DependencyHelper.active_job_wraps_args?
-      wrapped_args = {}
-
-      if params
-        if DependencyHelper.rails7_present?
-          wrapped_args["_aj_ruby2_keywords"] = ["params", "args"]
-          wrapped_args["args"] = []
-          wrapped_args["params"] = {
-            "_aj_symbol_keys" => ["foo"]
-          }.merge(params)
-        else
-          wrapped_args["_aj_symbol_keys"] = ["foo"]
-          wrapped_args.merge!(params)
-        end
-      else
-        wrapped_args["_aj_ruby2_keywords"] = ["args"]
-        wrapped_args["args"] = args
-      end
-
-      [wrapped_args]
-    else
-      params.nil? ? args : args + [params]
-    end
-  end
-end

data/spec/support/helpers/api_request_helper.rb

@@ -1,20 +0,0 @@
-module ApiRequestHelper
-  def stub_api_request(config, path, body = nil)
-    options = {
-      :query => {
-        :api_key => config[:push_api_key],
-        :name => config[:name],
-        :environment => config.respond_to?(:env) ? config.env : config[:environment],
-        :hostname => config[:hostname],
-        :gem_version => Appsignal::VERSION
-      },
-      :headers => {
-        "Content-Type" => "application/json; charset=UTF-8"
-      }
-    }
-    body = Appsignal::Utils::JSON.generate(body) if body.is_a? Hash
-    options[:body] = body if body
-    endpoint = config[:endpoint] || Appsignal::Config::DEFAULT_CONFIG[:endpoint]
-    stub_request(:post, "#{endpoint}/1/#{path}").with(options)
-  end
-end

data/spec/support/helpers/cli_helpers.rb

@@ -1,40 +0,0 @@
-require "appsignal/cli/helpers"
-
-module CLIHelpers
-  def cli
-    Appsignal::CLI
-  end
-
-  def run_cli(command, options = {})
-    cli.run(format_cli_arguments_and_options(command, options))
-  end
-
-  def format_cli_arguments_and_options(command, options = {})
-    [*command].tap do |o|
-      options.each do |key, value|
-        o << (value.nil? ? "--#{key}" : "--#{key}=#{value}")
-      end
-    end
-  end
-
-  def add_cli_input(value)
-    $stdin.puts value
-  end
-
-  def prepare_cli_input
-    # Prepare the input by rewinding the pointer in the StringIO
-    $stdin.rewind
-  end
-
-  def colorize(*args)
-    ColorizeHelper.colorize(*args)
-  end
-end
-
-module ColorizeHelper
-  extend Appsignal::CLI::Helpers
-
-  def self.colorize(*_args)
-    super
-  end
-end

data/spec/support/helpers/config_helpers.rb

@@ -1,66 +0,0 @@
-module ConfigHelpers
-  def project_fixture_path
-    File.expand_path(
-      File.join(File.dirname(__FILE__), "../fixtures/projects/valid")
-    )
-  end
-  module_function :project_fixture_path
-
-  def rails_project_fixture_path
-    File.expand_path(
-      File.join(File.dirname(__FILE__), "../fixtures/projects/valid_with_rails_app")
-    )
-  end
-  module_function :rails_project_fixture_path
-
-  def project_fixture_config(
-    env = "production",
-    options = {},
-    logger = Appsignal.internal_logger
-  )
-    Appsignal::Config.new(
-      project_fixture_path,
-      env,
-      logger
-    ).tap do |c|
-      c.merge_dsl_options(options)
-      c.validate
-    end
-  end
-  module_function :project_fixture_config
-
-  def build_config(
-    root_path: project_fixture_path,
-    env: "production",
-    options: {},
-    logger: Appsignal.internal_logger
-  )
-    Appsignal::Config.new(
-      root_path,
-      env,
-      logger
-    ).tap do |c|
-      c.merge_dsl_options(options) if options.any?
-      c.validate
-    end
-  end
-  module_function :build_config
-
-  def start_agent(env: "production", options: {}, internal_logger: nil)
-    env = "production" if env == :default
-    env ||= "production"
-    Appsignal.configure(env, :root_path => project_fixture_path) do |config|
-      options.each do |option, value|
-        config.send("#{option}=", value)
-      end
-    end
-    Appsignal.start
-    Appsignal.internal_logger = internal_logger if internal_logger
-  end
-
-  def clear_integration_env_vars!
-    ENV.delete("RAILS_ENV")
-    ENV.delete("RACK_ENV")
-    ENV.delete("PADRINO_ENV")
-  end
-end

data/spec/support/helpers/dependency_helper.rb

@@ -1,150 +0,0 @@
-module DependencyHelper
-  module_function
-
-  def macos?
-    RbConfig::CONFIG["host_os"].include?("darwin")
-  end
-
-  def ruby_version
-    Gem::Version.new(RUBY_VERSION)
-  end
-
-  def ruby_3_1_or_newer?
-    ruby_version >= Gem::Version.new("3.1.0")
-  end
-
-  def ruby_3_2_or_newer?
-    ruby_version >= Gem::Version.new("3.2.0")
-  end
-
-  def running_jruby?
-    Appsignal::System.jruby?
-  end
-
-  def rails_present?
-    dependency_present? "rails"
-  end
-
-  def rails6_present?
-    rails_present? && rails_version >= Gem::Version.new("6.0.0")
-  end
-
-  def rails6_1_present?
-    rails_present? && rails_version >= Gem::Version.new("6.1.0")
-  end
-
-  def rails6_1_5_present?
-    rails_present? && rails_version >= Gem::Version.new("6.1.5")
-  end
-
-  def rails7_present?
-    rails_present? && rails_version >= Gem::Version.new("7.0.0")
-  end
-
-  def rails7_1_present?
-    rails_present? && rails_version >= Gem::Version.new("7.1.0")
-  end
-
-  def active_job_wraps_args?
-    rails7_present? || (ruby_3_1_or_newer? && rails6_1_present? && !rails6_1_5_present?)
-  end
-
-  def rails_version
-    Gem.loaded_specs["rails"].version
-  end
-
-  def sequel_present?
-    dependency_present? "sequel"
-  end
-
-  def resque_present?
-    dependency_present? "resque"
-  end
-
-  def redis_client_present?
-    dependency_present? "redis-client"
-  end
-
-  def hiredis_client_present?
-    dependency_present? "hiredis-client"
-  end
-
-  def redis_present?
-    dependency_present? "redis"
-  end
-
-  def action_cable_present?
-    dependency_present? "actioncable"
-  end
-
-  def action_mailer_present?
-    dependency_present? "actionmailer"
-  end
-
-  def active_job_present?
-    dependency_present? "activejob"
-  end
-
-  def active_support_present?
-    dependency_present? "activesupport"
-  end
-
-  def sinatra_present?
-    dependency_present? "sinatra"
-  end
-
-  def padrino_present?
-    dependency_present? "padrino"
-  end
-
-  def grape_present?
-    dependency_present? "grape"
-  end
-
-  def webmachine_present?
-    dependency_present? "webmachine"
-  end
-
-  def capistrano_present?
-    dependency_present? "capistrano"
-  end
-
-  def capistrano2_present?
-    capistrano_present? &&
-      Gem.loaded_specs["capistrano"].version < Gem::Version.new("3.0")
-  end
-
-  def capistrano3_present?
-    capistrano_present? &&
-      Gem.loaded_specs["capistrano"].version >= Gem::Version.new("3.0")
-  end
-
-  def http_present?
-    dependency_present? "http"
-  end
-
-  def que_present?
-    dependency_present? "que"
-  end
-
-  def hanami_present?
-    dependency_present? "hanami"
-  end
-
-  def hanami2_1_present?
-    hanami_present? &&
-      Gem::Version.new(::Hanami::VERSION) >= Gem::Version.new("2.1.0")
-  end
-
-  def dry_monitor_present?
-    dependency_present? "dry-monitor"
-  end
-
-  def hanami2_present?
-    hanami_present? && Gem.loaded_specs["hanami"].version >= Gem::Version.new("2.0")
-  end
-
-  def dependency_present?(dependency_file)
-    Gem.loaded_specs.key? dependency_file
-  end
-end

data/spec/support/helpers/directory_helper.rb

@@ -1,27 +0,0 @@
-module DirectoryHelper
-  module_function
-
-  def project_dir
-    @project_dir ||= File.expand_path("..", spec_dir)
-  end
-
-  def spec_dir
-    APPSIGNAL_SPEC_DIR
-  end
-
-  def support_dir
-    @support_dir ||= File.join(spec_dir, "support")
-  end
-
-  def tmp_dir
-    @tmp_dir ||= File.join(spec_dir, "tmp")
-  end
-
-  def fixtures_dir
-    @fixtures_dir ||= File.join(support_dir, "fixtures")
-  end
-
-  def resources_dir
-    @resources_dir ||= File.join(project_dir, "resources")
-  end
-end

data/spec/support/helpers/env_helpers.rb

@@ -1,41 +0,0 @@
-module EnvHelpers
-  def http_request_env_with_data(args = {})
-    with_queue_start = args.delete(:with_queue_start)
-    path = args.delete(:path) || "/blog"
-    request = Rack::MockRequest.env_for(
-      path,
-      :params => args[:params] || {
-        "controller" => "blog_posts",
-        "action" => "show",
-        "id" => "1"
-      }
-    ).merge(
-      :controller => "BlogPostsController",
-      :action => "show",
-      :request_format => "html",
-      :request_method => "GET",
-      :status => "200",
-      :view_runtime => 500,
-      :db_runtime => 500,
-      :metadata => { :key => "value" }
-    ).merge(args)
-
-    # Set default queue value
-    if with_queue_start
-      request["HTTP_X_QUEUE_START"] = "t=#{(fixed_time * 1_000).to_i}" # in milliseconds
-    end
-
-    request
-  end
-
-  def background_env_with_data(args = {})
-    {
-      :class => "BackgroundJob",
-      :method => "perform",
-      :priority => 1,
-      :attempts => 0,
-      :queue => "default",
-      :queue_start => fixed_time
-    }.merge(args)
-  end
-end

data/spec/support/helpers/environment_metdata_helper.rb

@@ -1,16 +0,0 @@
-module EnvironmentMetadataHelper
-  def capture_environment_metadata_report_calls
-    allow(Appsignal::Extension).to receive(:set_environment_metadata)
-      .and_call_original
-  end
-
-  def expect_environment_metadata(key, value)
-    expect(Appsignal::Extension).to have_received(:set_environment_metadata)
-      .with(key, value)
-  end
-
-  def expect_not_environment_metadata(key)
-    expect(Appsignal::Extension).to_not have_received(:set_environment_metadata)
-      .with(key, anything)
-  end
-end

data/spec/support/helpers/example_exception.rb

@@ -1,13 +0,0 @@
-# This ExampleException is used for throwing Exceptions in specs that are
-# allowed or expected.
-#
-# For example, this error can be thrown to raise an exception in AppSignal's
-# run, which should stop the program and the appsignal gem, but not crash the
-# test suite.
-#
-# There's also {ExampleStandardError}, use this when you need to test against
-# StandardError-level Ruby exceptions.
-#
-# @see ExampleStandardError
-class ExampleException < Exception # rubocop:disable Lint/InheritException
-end

data/spec/support/helpers/example_standard_error.rb

@@ -1,13 +0,0 @@
-# This ExampleStandardError is used for throwing errors in specs that are
-# allowed or expected.
-#
-# For example, this error can be thrown to raise an exception in AppSignal's
-# run, which should stop the program and the appsignal gem, but not crash the
-# test suite.
-#
-# There's also {ExampleException}, use this when you need to test against
-# Exception-level Ruby exceptions.
-#
-# @see ExampleException
-class ExampleStandardError < StandardError
-end

data/spec/support/helpers/loader_helper.rb

@@ -1,21 +0,0 @@
-module LoaderHelper
-  def load_loader(name)
-    Appsignal.load(name)
-  end
-
-  def start_loader(name)
-    Appsignal::Loaders.instances.fetch(name).on_start
-  end
-
-  def unregister_loader(name)
-    Appsignal::Loaders.unregister(name)
-  end
-
-  def define_loader(name, &block)
-    Appsignal::Testing.registered_loaders << name
-    Class.new(Appsignal::Loaders::Loader) do
-      register name
-      class_eval(&block) if block_given?
-    end
-  end
-end

data/spec/support/helpers/log_helpers.rb

@@ -1,36 +0,0 @@
-module LogHelpers
-  def capture_logs(&block)
-    log = std_stream
-    use_logger_with(log, &block)
-    log_contents(log)
-  end
-
-  def use_logger_with(log)
-    Appsignal.internal_logger = test_logger(log)
-    yield
-  ensure
-    Appsignal.internal_logger = nil
-  end
-
-  def test_logger(log)
-    Appsignal::Utils::IntegrationLogger.new(log).tap do |logger|
-      logger.formatter = logger_formatter
-    end
-  end
-
-  def logger_formatter
-    proc do |severity, _datetime, _progname, msg|
-      log_line(severity, msg)
-    end
-  end
-
-  def log_line(severity, message)
-    # This format is used in the `contains_log` matcher.
-    "[#{severity}] #{message}\n"
-  end
-
-  def log_contents(log)
-    log.rewind
-    log.read
-  end
-end

data/spec/support/helpers/rails_helper.rb

@@ -1,28 +0,0 @@
-module RailsHelper
-  def run_appsignal_railtie
-    app = MyApp::Application.new
-    Appsignal::Integrations::Railtie.initializers.each do |initializer|
-      initializer.run(app)
-    end
-    ActiveSupport.run_load_hooks(:after_initialize, app)
-  end
-
-  def with_rails_error_reporter
-    if Rails.respond_to? :error
-      clear_rails_error_reporter!
-      Appsignal::Integrations::Railtie.initialize_error_reporter
-    end
-    yield
-  ensure
-    clear_rails_error_reporter!
-  end
-
-  def clear_rails_error_reporter!
-    return unless Rails.respond_to? :error
-
-    Rails
-      .error
-      .instance_variable_get(:@subscribers)
-      .reject! { |s| s == Appsignal::Integrations::RailsErrorReporterSubscriber }
-  end
-end

data/spec/support/helpers/std_streams_helper.rb

@@ -1,94 +0,0 @@
-module StdStreamsHelper
-  def std_stream
-    Tempfile.new SecureRandom.uuid
-  end
-
-  # Capture STDOUT in a variable
-  #
-  # Given tempfiles are rewinded and unlinked after yield, so no cleanup
-  # required. You can read from the stream using `stdout.read`.
-  #
-  # Usage
-  #
-  #     out_stream = Tempfile.new
-  #     capture_stdout(out_stream) { do_something }
-  def capture_stdout(stdout)
-    original_stdout = $stdout.dup
-    $stdout.reopen stdout
-
-    yield
-  ensure
-    $stdout.reopen original_stdout
-    stdout.rewind
-    stdout.unlink
-  end
-
-  # Capture STDOUT and STDERR in variables
-  #
-  # Given tempfiles are rewinded and unlinked after yield, so no cleanup
-  # required. You can read from the stream using `stdout.read`.
-  #
-  # Usage
-  #
-  #     out_stream = Tempfile.new
-  #     err_stream = Tempfile.new
-  #     capture_std_streams(out_stream, err_stream) { do_something }
-  def capture_std_streams(stdout, stderr)
-    original_stdout = $stdout.dup
-    $stdout.reopen stdout
-    original_stderr = $stderr.dup
-    $stderr.reopen stderr
-
-    yield
-  ensure
-    $stdout.reopen original_stdout
-    $stderr.reopen original_stderr
-    stdout.rewind
-    stdout.unlink
-    stderr.rewind
-    stderr.unlink
-  end
-
-  # Silence the STDOUT.
-  #
-  # Ignore the STDOUT and don't print it in the test suite's STDOUT.
-  #
-  # If an error is found the output the output is raised as an error, failing
-  # the spec. Warnings and other AppSignal messages are ignored.
-  #
-  # @example
-  #   silence { do_something }
-  #   # Does nothing
-  #
-  #   silence { puts "ERROR!" }
-  #   # => Error found in silenced output:
-  #   # ERROR!
-  #
-  # @example Ignore certain errors
-  #   silence(:allowed => ["my error"]) { puts "my error!" }
-  #   # Does nothing
-  #
-  #   silence { puts "my error!" }
-  #   # => Error found in silenced output:
-  #   # my error!
-  def silence(options = {}, &block)
-    stream = Tempfile.new(SecureRandom.uuid)
-    capture_std_streams(stream, stream, &block)
-  ensure
-    output = filter_allowed_errors(stream.read, options.fetch(:allowed, []))
-    raise "Error found in silenced output:\n#{output}" if output =~ /(ERR|Error|error)/
-  end
-
-  def filter_allowed_errors(output, allowed_errors)
-    output.lines.reject do |line|
-      reject = false
-      allowed_errors.each do |error|
-        if line.include?(error)
-          reject = true
-          break
-        end
-      end
-      reject
-    end.join
-  end
-end

data/spec/support/helpers/system_helpers.rb

@@ -1,8 +0,0 @@
-module SystemHelpers
-  def recognize_as_heroku
-    ENV["DYNO"] = "dyno1"
-    value = yield
-    ENV.delete "DYNO"
-    value
-  end
-end

data/spec/support/helpers/take_at_most_helper.rb

@@ -1,21 +0,0 @@
-module TakeAtMostHelper
-  # Assert that it takes at most a certain amount of time to run a block.
-  #
-  # @example
-  #  # Assert that it takes at most 1 second to run the block
-  #  take_at_most(1) { sleep 0.5 }
-  #
-  # @param time [Integer, Float] The maximum amount of time the block is allowed to
-  #  run in seconds.
-  # @yield Block to run.
-  # @raise [StandardError] Raises error if the block takes longer than the
-  #  specified time to run.
-  def take_at_most(time)
-    start = Time.now
-    yield
-    elapsed = Time.now - start
-    return if elapsed <= time
-
-    raise "Expected block to take at most #{time} seconds, but took #{elapsed}"
-  end
-end