appsignal 4.0.5 → 4.0.7

data/spec/support/helpers/time_helpers.rb

@@ -1,11 +0,0 @@
-module TimeHelpers
-  def fixed_time
-    @fixed_time ||= Time.utc(2014, 1, 15, 11, 0, 0).to_f
-  end
-
-  def advance_frozen_time(time, addition)
-    Time.at(time.to_f + addition).tap do |new_time|
-      Timecop.freeze(new_time)
-    end
-  end
-end

data/spec/support/helpers/transaction_helpers.rb

@@ -1,122 +0,0 @@
-module TransactionHelpers
-  def uploaded_file
-    if DependencyHelper.rails_present?
-      ActionDispatch::Http::UploadedFile.new(:tempfile => "/tmp")
-    else
-      ::Rack::Multipart::UploadedFile.new(File.join(fixtures_dir, "/uploaded_file.txt"))
-    end
-  end
-
-  def default_namespace
-    Appsignal::Transaction::HTTP_REQUEST
-  end
-
-  def create_transaction(namespace = default_namespace)
-    Appsignal::Transaction.create(namespace)
-  end
-
-  def new_transaction(namespace = default_namespace, ext: nil)
-    Appsignal::Transaction.new(namespace, :ext => ext)
-  end
-
-  def rack_request(env)
-    Rack::Request.new(env)
-  end
-
-  def background_job_transaction
-    new_transaction(Appsignal::Transaction::BACKGROUND_JOB)
-  end
-
-  def http_request_transaction
-    new_transaction(Appsignal::Transaction::HTTP_REQUEST)
-  end
-
-  # Returns the all {Appsignal::Transaction} objects created during this test
-  # run so far.
-  #
-  # @return [Array<Appsignal::Transaction>]
-  def created_transactions
-    Appsignal::Testing.transactions
-  end
-
-  # Returns the last created {Appsignal::Transaction}.
-  #
-  # @return [Appsignal::Transaction]
-  def last_transaction
-    created_transactions.last
-  end
-
-  def current_transaction?
-    Appsignal::Transaction.current?
-  end
-
-  def current_transaction
-    Appsignal::Transaction.current
-  end
-
-  # Set current transaction manually.
-  # Cleared by {clear_current_transaction!}
-  #
-  # When a block is given, the current transaction is automatically unset after
-  # the block.
-  def set_current_transaction(transaction) # rubocop:disable Naming/AccessorMethodName
-    Thread.current[:appsignal_transaction] = transaction
-    yield if block_given?
-  ensure
-    clear_current_transaction! if block_given?
-  end
-
-  # Use when {Appsignal::Transaction.clear_current_transaction!} is stubbed to
-  # clear the current transaction on the current thread.
-  def clear_current_transaction!
-    Thread.current[:appsignal_transaction] = nil
-  end
-
-  # Set the current for the duration of the given block.
-  #
-  # Helper for {set_current_transaction} and {clear_current_transaction!}
-  def with_current_transaction(transaction)
-    set_current_transaction transaction
-    yield
-  ensure
-    clear_current_transaction!
-  end
-
-  # Track the AppSignal transaction JSON when a transaction gets completed
-  # ({Appsignal::Transaction.complete}).
-  #
-  # It will also add sample data to the transaction when it gets completed.
-  # This can be disabled by setting the `sample` option to `false`.
-  #
-  # It will be tracked for every transaction that is started inside the
-  # `keep_transactions` block.
-  #
-  # @example Keep a transaction while also adding sample data
-  #   keep_transactions do
-  #     transaction = Appsignal::Transaction.new(...)
-  #     transaction.complete
-  #     transaction.to_h # => Hash with transaction data before it was completed
-  #   end
-  #
-  # @example Keep a transaction without adding sample data
-  #   keep_transactions :sample => false do
-  #     transaction = Appsignal::Transaction.new(...)
-  #     transaction.complete
-  #     transaction.to_h
-  #     # => Hash with transaction data before it was completed with an empty
-  #     #    Hash for the `sample_data` key.
-  #   end
-  #
-  # @yield block to perform while the transactions are tracked.
-  # @param options [Hash]
-  # @option options [Boolean] :sample Whether or not to sample transactions.
-  # @return [Object] returns the block return value.
-  def keep_transactions(options = {})
-    Appsignal::Testing.keep_transactions = true
-    Appsignal::Testing.sample_transactions = options.fetch(:sample, true)
-    yield
-  ensure
-    Appsignal::Testing.keep_transactions = nil
-    Appsignal::Testing.sample_transactions = nil
-  end
-end

data/spec/support/helpers/wait_for_helper.rb

@@ -1,39 +0,0 @@
-module WaitForHelper
-  # Wait for a condition to be met
-  #
-  # @example
-  #   # Perform threaded operation
-  #   wait_for("enough probe calls") { probe.calls >= 2 }
-  #   # Assert on result
-  #
-  # @param name [String] The name of the condition to check. Used in the
-  #   error when it fails.
-  # @yield Assertion to check.
-  # @yieldreturn [Boolean] True/False value that indicates if the condition
-  #   is met.
-  # @raise [StandardError] Raises error if the condition is not met after 5
-  #   seconds, 5_000 tries.
-  def wait_for(name)
-    max_wait = 5_000
-    i = 0
-    error = nil
-    while i < max_wait
-      begin
-        result = yield
-        break if result
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        # Capture error so we know if it exited with an error
-        error = e
-      ensure
-        i += 1
-        sleep 0.001
-      end
-    end
-
-    return unless i >= max_wait
-
-    error_message =
-      ("\nError: #{error.class}: #{error.message}\n#{error.backtrace.join("\n")}" if error)
-    raise "Waited 5 seconds for #{name} condition, but was not met.#{error_message}"
-  end
-end

data/spec/support/matchers/contains_log.rb

@@ -1,26 +0,0 @@
-RSpec::Matchers.define :contains_log do |level, message|
-  log_level_prefix = level.upcase
-
-  match do |actual|
-    case message
-    when Regexp
-      /\[#{log_level_prefix}\] #{message}/.match?(actual)
-    else
-      expected_log_line = "[#{log_level_prefix}] #{message}"
-      actual.include?(expected_log_line)
-    end
-  end
-
-  failure_message do |actual|
-    <<~MESSAGE
-      Did not contain log line:
-      Log level: #{log_level_prefix}
-      Message: #{message}
-
-      Received logs:
-      #{actual}
-    MESSAGE
-  end
-
-  diffable
-end

data/spec/support/matchers/have_colorized_text.rb

@@ -1,28 +0,0 @@
-RSpec::Matchers.define :have_colorized_text do |color, text|
-  match do |actual|
-    color_codes = Appsignal::CLI::Helpers::COLOR_CODES
-    reset_color_code = color_codes.fetch(:default)
-    color_code = color_codes.fetch(color)
-
-    @expected = "\e[#{color_code}m#{text}\e[#{reset_color_code}m"
-    expect(actual).to include(@expected)
-  end
-
-  diffable
-  attr_reader :expected
-end
-
-COLOR_TAG_MATCHER_REGEX = /\e\[(\d+)m/.freeze
-RSpec::Matchers.define :have_color_markers do
-  match do |actual|
-    actual =~ COLOR_TAG_MATCHER_REGEX
-  end
-
-  failure_message do
-    "expected that output contains color markers: /\\e[\\d+m/"
-  end
-
-  failure_message_when_negated do
-    "expected that output does not contain color markers: /\\e[\\d+m/"
-  end
-end

data/spec/support/matchers/transaction.rb

@@ -1,200 +0,0 @@
-def define_transaction_metadata_matcher_for(matcher_key, value_key = matcher_key)
-  value_key = value_key.to_s
-
-  RSpec::Matchers.define "have_#{matcher_key}" do |expected_value|
-    match(:notify_expectation_failures => true) do |transaction|
-      actual_value = transaction.to_h[value_key]
-      if expected_value
-        expect(actual_value).to eq(expected_value)
-      else
-        expect(actual_value).to_not be_nil
-      end
-    end
-
-    match_when_negated(:notify_expectation_failures => true) do |transaction|
-      actual_value = transaction.to_h[value_key]
-      if expected_value
-        expect(actual_value).to_not eq(expected_value)
-      else
-        expect(actual_value).to be_nil
-      end
-    end
-  end
-end
-
-define_transaction_metadata_matcher_for(:id)
-define_transaction_metadata_matcher_for(:namespace)
-define_transaction_metadata_matcher_for(:action)
-
-def define_transaction_sample_matcher_for(matcher_key, value_key = matcher_key)
-  value_key = value_key.to_s
-
-  RSpec::Matchers.define "include_#{matcher_key}" do |expected_value|
-    match(:notify_expectation_failures => true) do |transaction|
-      sample_data = transaction.to_h.dig("sample_data", value_key) || {}
-
-      if expected_value
-        expected_value = hash_including(expected_value) if expected_value.is_a?(Hash)
-        expect(sample_data).to match(expected_value)
-      else
-        expect(sample_data).to be_present
-      end
-    end
-
-    match_when_negated(:notify_expectation_failures => true) do |transaction|
-      sample_data = transaction.to_h.dig("sample_data", value_key) || {}
-
-      if expected_value
-        expect(sample_data).to_not include(expected_value)
-      else
-        expect(sample_data).to be_empty
-      end
-    end
-  end
-end
-
-define_transaction_sample_matcher_for(:sample_metadata, :metadata)
-define_transaction_sample_matcher_for(:params)
-define_transaction_sample_matcher_for(:environment)
-define_transaction_sample_matcher_for(:session_data)
-define_transaction_sample_matcher_for(:tags)
-define_transaction_sample_matcher_for(:custom_data)
-define_transaction_sample_matcher_for(:error_causes)
-
-RSpec::Matchers.define :be_completed do
-  match(:notify_expectation_failures => true) do |transaction|
-    values_match? transaction.ext._completed?, true
-  end
-end
-
-RSpec::Matchers.define :have_error do |error_class, error_message, error_backtrace|
-  match(:notify_expectation_failures => true) do |transaction|
-    transaction_error = transaction.to_h["error"]
-    if error_class && error_message
-      expect(transaction_error).to include(
-        "name" => error_class,
-        "message" => error_message,
-        "backtrace" => error_backtrace ? JSON.dump(error_backtrace) : kind_of(String)
-      )
-    else
-      expect(transaction_error).to be_any
-    end
-  end
-
-  match_when_negated(:notify_expectation_failures => true) do |transaction|
-    transaction_error = transaction.to_h["error"]
-    if error_class && error_message
-      expect(transaction_error).to_not include(
-        "name" => error_class,
-        "message" => error_message,
-        "backtrace" => kind_of(String)
-      )
-    else
-      expect(transaction_error).to be_nil
-    end
-  end
-end
-
-RSpec::Matchers.define :include_event do |event|
-  match(:notify_expectation_failures => true) do |transaction|
-    events = transaction.to_h["events"]
-    if event
-      expect(events).to include(format_event(event))
-    else
-      expect(events).to be_any
-    end
-  end
-
-  match_when_negated(:notify_expectation_failures => true) do |transaction|
-    events = transaction.to_h["events"]
-    if event
-      expect(events).to_not include(format_event(event))
-    else
-      expect(events).to be_empty
-    end
-  end
-
-  def format_event(event)
-    hash_including({
-      "body" => "",
-      "body_format" => Appsignal::EventFormatter::DEFAULT,
-      "count" => 1,
-      "name" => kind_of(String),
-      "title" => ""
-    }.merge(event.transform_keys(&:to_s)))
-  end
-end
-RSpec::Matchers.alias_matcher :include_events, :include_event
-
-RSpec::Matchers.define :include_metadata do |metadata|
-  match(:notify_expectation_failures => true) do |transaction|
-    actual_metadata = transaction.to_h["metadata"]
-    if metadata
-      expect(actual_metadata).to include(metadata)
-    else
-      expect(actual_metadata).to be_any
-    end
-  end
-
-  match_when_negated(:notify_expectation_failures => true) do |transaction|
-    actual_metadata = transaction.to_h["metadata"]
-    if metadata
-      expect(actual_metadata).to_not include(metadata)
-    else
-      expect(actual_metadata).to be_empty
-    end
-  end
-end
-
-RSpec::Matchers.define :include_breadcrumb do |action, category, message, metadata, time|
-  match(:notify_expectation_failures => true) do |transaction|
-    breadcrumbs = transaction.to_h.dig("sample_data", "breadcrumbs")
-    if action
-      breadcrumb = format_breadcrumb(action, category, message, metadata, time)
-      expect(breadcrumbs).to include(breadcrumb)
-    else
-      expect(transaction.to_h.dig("sample_data", "breadcrumbs")).to be_any
-    end
-  end
-
-  match_when_negated(:notify_expectation_failures => true) do |transaction|
-    breadcrumbs = transaction.to_h.dig("sample_data", "breadcrumbs")
-    if action
-      breadcrumb = format_breadcrumb(action, category, message, metadata, time)
-      expect(breadcrumbs).to_not include(breadcrumb)
-    else
-      expect(breadcrumbs).to_not be_any
-    end
-  end
-
-  def format_breadcrumb(action, category, message, metadata, time)
-    {
-      "action" => action,
-      "category" => category,
-      "message" => message || "",
-      "metadata" => metadata || {},
-      "time" => time || kind_of(Integer)
-    }
-  end
-end
-RSpec::Matchers.alias_matcher :include_breadcrumbs, :include_breadcrumb
-
-RSpec::Matchers.define :have_queue_start do |queue_start_time|
-  match(:notify_expectation_failures => true) do |transaction|
-    actual_start = transaction.ext.queue_start
-    if queue_start_time
-      expect(actual_start).to eq(queue_start_time)
-    else
-      expect(actual_start).to_not be_nil
-    end
-  end
-
-  match_when_negated(:notify_expectation_failures => true) do |transaction|
-    actual_start = transaction.ext.queue_start
-    if queue_start_time
-      expect(actual_start).to_not eq(queue_start_time)
-    else
-      expect(actual_start).to be_nil
-    end
-  end
-end

data/spec/support/mocks/appsignal_mock.rb

@@ -1,18 +0,0 @@
-class AppsignalMock
-  attr_reader :gauges
-
-  def initialize(hostname: nil)
-    @hostname = hostname
-    @gauges = []
-  end
-
-  def config
-    options = {}
-    options[:hostname] = @hostname if @hostname
-    ConfigHelpers.build_config(:options => options)
-  end
-
-  def set_gauge(*args)
-    @gauges << args
-  end
-end

data/spec/support/mocks/dummy_app.rb

@@ -1,20 +0,0 @@
-class DummyApp
-  def initialize(&app)
-    @app = app
-    @called = false
-  end
-
-  def call(env)
-    if @app
-      @app&.call(env)
-    else
-      [200, {}, ["body"]]
-    end
-  ensure
-    @called = true
-  end
-
-  def called?
-    @called
-  end
-end

data/spec/support/mocks/fake_gc_profiler.rb

@@ -1,19 +0,0 @@
-class FakeGCProfiler
-  attr_accessor :total_time
-  attr_writer :clear_delay
-
-  def initialize(total_time = 0)
-    @total_time = total_time
-  end
-
-  def clear
-    sleep clear_delay
-    @total_time = 0
-  end
-
-  private
-
-  def clear_delay
-    @clear_delay ||= 0
-  end
-end

data/spec/support/mocks/fake_gvl_tools.rb

@@ -1,28 +0,0 @@
-module FakeGVLTools
-  def self.reset
-    self::GlobalTimer.monotonic_time = 0
-    self::WaitingThreads.count = 0
-  end
-
-  module GlobalTimer
-    @monotonic_time = 0
-
-    class << self
-      attr_accessor :monotonic_time
-    end
-  end
-
-  module WaitingThreads
-    @count = 0
-    @enabled = false
-
-    class << self
-      attr_accessor :count
-      attr_writer :enabled
-
-      def enabled?
-        @enabled
-      end
-    end
-  end
-end

data/spec/support/mocks/hash_like.rb

@@ -1,10 +0,0 @@
-class HashLike < Hash
-  def initialize(value)
-    super
-    @value = value
-  end
-
-  def to_h
-    @value
-  end
-end

data/spec/support/mocks/mock_probe.rb

@@ -1,13 +0,0 @@
-class MockProbe
-  attr_reader :calls
-
-  def initialize
-    Appsignal::Testing.store[:mock_probe_call] = 0
-    @calls = 0
-  end
-
-  def call
-    Appsignal::Testing.store[:mock_probe_call] += 1
-    @calls += 1
-  end
-end

data/spec/support/mocks/puma_mock.rb

@@ -1,43 +0,0 @@
-class PumaMock
-  module MiniSSL
-    class SSLError < StandardError
-      def self.to_s
-        "Puma::MiniSSL::SSLError"
-      end
-    end
-  end
-
-  class HttpParserError < StandardError
-    def self.to_s
-      "Puma::HttpParserError"
-    end
-  end
-
-  class HttpParserError501 < StandardError
-    def self.to_s
-      "Puma::HttpParserError501"
-    end
-  end
-
-  def self.stats
-  end
-
-  def self.cli_config
-    @cli_config ||= CliConfig.new
-  end
-
-  class Server
-  end
-
-  module Const
-    VERSION = "6.0.0".freeze
-  end
-
-  class CliConfig
-    attr_accessor :options
-
-    def initialize
-      @options = {}
-    end
-  end
-end

data/spec/support/shared_examples/instrument.rb

@@ -1,48 +0,0 @@
-RSpec.shared_examples "instrument helper" do
-  around { |example| keep_transactions { example.run } }
-  let(:stub) { double(:method_call => "return value") }
-
-  it "records an event around the given block" do
-    return_value = instrumenter.instrument "name", "title", "body" do
-      stub.method_call
-    end
-    expect(return_value).to eq "return value"
-
-    expect_transaction_to_have_event
-  end
-
-  context "with an error raised in the passed block" do
-    it "records an event around the given block" do
-      expect do
-        instrumenter.instrument "name", "title", "body" do
-          stub.method_call
-          raise ExampleException, "foo"
-        end
-      end.to raise_error(ExampleException, "foo")
-
-      expect_transaction_to_have_event
-    end
-  end
-
-  context "with an error raise in the passed block" do
-    it "records an event around the given block" do
-      expect do
-        instrumenter.instrument "name", "title", "body" do
-          stub.method_call
-          throw :foo
-        end
-      end.to throw_symbol(:foo)
-
-      expect_transaction_to_have_event
-    end
-  end
-
-  def expect_transaction_to_have_event
-    expect(transaction).to include_event(
-      "name" => "name",
-      "title" => "title",
-      "body" => "body",
-      "body_format" => Appsignal::EventFormatter::DEFAULT
-    )
-  end
-end

data/spec/support/stubs/appsignal/loaders/loader_stub.rb

@@ -1,7 +0,0 @@
-module Appsignal
-  module Loaders
-    class LoaderStub < Loader
-      register :loader_stub
-    end
-  end
-end

data/spec/support/stubs/sidekiq/api.rb

@@ -1,4 +0,0 @@
-module Sidekiq
-  class Stats
-  end
-end