appsignal 4.0.6-java → 4.0.8-java

data/spec/lib/appsignal/demo_spec.rb

@@ -1,83 +0,0 @@
-require "appsignal/demo"
-
-describe Appsignal::Demo do
-  before do
-    # Ignore sleeps to speed up the test
-    allow(described_class).to receive(:sleep)
-  end
-
-  describe ".transmit" do
-    subject { described_class.transmit }
-
-    context "without config" do
-      it "returns false" do
-        expect(silence { subject }).to eq(false)
-      end
-    end
-
-    context "with config" do
-      before { start_agent }
-
-      it "returns true" do
-        expect(subject).to eq(true)
-      end
-
-      it "creates demonstration samples" do
-        expect(described_class).to receive(:create_example_error_request)
-        expect(described_class).to receive(:create_example_performance_request)
-        subject
-      end
-    end
-  end
-
-  describe ".create_example_error_request" do
-    before { start_agent }
-    around { |example| keep_transactions { example.run } }
-
-    it "sets an error" do
-      described_class.send(:create_example_error_request)
-
-      transaction = last_transaction
-      expect(transaction).to have_id
-      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-      expect(transaction).to have_action("DemoController#hello")
-      expect(transaction).to have_error(
-        "Appsignal::Demo::TestError",
-        "Hello world! This is an error used for demonstration purposes."
-      )
-      expect(transaction).to include_metadata(
-        "path" => "/hello",
-        "method" => "GET",
-        "demo_sample" => "true"
-      )
-      expect(transaction).to be_completed
-    end
-  end
-
-  describe ".create_example_performance_request" do
-    before { start_agent }
-    around { |example| keep_transactions { example.run } }
-
-    it "sends a performance sample" do
-      described_class.send(:create_example_performance_request)
-
-      transaction = last_transaction
-      expect(transaction).to have_id
-      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-      expect(transaction).to have_action("DemoController#hello")
-      expect(transaction).to_not have_error
-      expect(transaction).to include_metadata(
-        "path" => "/hello",
-        "method" => "GET",
-        "demo_sample" => "true"
-      )
-      expect(transaction).to include_event(
-        "name" => "action_view.render",
-        "title" => "Render hello.html.erb",
-        "body" => "<h1>Hello world!</h1>",
-        "body_format" => Appsignal::EventFormatter::DEFAULT
-      )
-      expect(transaction).to be_completed
-    end
-  end
-end

data/spec/lib/appsignal/environment_spec.rb

@@ -1,190 +0,0 @@
-describe Appsignal::Environment do
-  include EnvironmentMetadataHelper
-
-  before do
-    start_agent
-    capture_environment_metadata_report_calls
-  end
-
-  def report(key, &value_block)
-    described_class.report(key, &value_block)
-  end
-
-  describe ".report" do
-    it "sends environment metadata to the extension" do
-      logs =
-        capture_logs do
-          report("_test_ruby_version") { "1.0.0" }
-          expect_environment_metadata("_test_ruby_version", "1.0.0")
-        end
-      expect(logs).to be_empty
-    end
-
-    context "when the key is a non String type" do
-      it "does not set the value" do
-        logs =
-          capture_logs do
-            report(:_test_symbol) { "1.0.0" }
-            expect_not_environment_metadata(:_test_symbol)
-            expect_not_environment_metadata("_test_symbol")
-          end
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report on environment metadata: Unsupported value type for :_test_symbol"
-        )
-      end
-    end
-
-    context "when the key is nil" do
-      it "does not set the value" do
-        logs =
-          capture_logs do
-            report(nil) { "1" }
-            expect_not_environment_metadata(nil)
-          end
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report on environment metadata: Unsupported value type for nil"
-        )
-      end
-    end
-
-    context "when the value is true or false" do
-      it "reports true or false as Strings" do
-        logs =
-          capture_logs do
-            report("_test_true") { true }
-            report("_test_false") { false }
-            expect_environment_metadata("_test_true", "true")
-            expect_environment_metadata("_test_false", "false")
-          end
-        expect(logs).to be_empty
-      end
-    end
-
-    context "when the value is nil" do
-      it "does not set the value" do
-        logs =
-          capture_logs do
-            report("_test_ruby_version") { nil }
-            expect_not_environment_metadata("_test_ruby_version")
-          end
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report on environment metadata \"_test_ruby_version\": " \
-            "Unsupported value type for nil"
-        )
-      end
-    end
-
-    context "when the value block raises an error" do
-      it "does not re-raise the error and writes it to the log" do
-        logs =
-          capture_logs do
-            report("_test_error") { raise "uh oh" }
-            expect_not_environment_metadata("_test_error")
-          end
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report on environment metadata \"_test_error\":\n" \
-            "RuntimeError: uh oh"
-        )
-      end
-    end
-
-    context "when something unforeseen errors" do
-      it "does not re-raise the error and writes it to the log" do
-        klass = Class.new do
-          def inspect
-            raise "inspect error"
-          end
-        end
-
-        logs =
-          capture_logs do
-            report(klass.new) { raise "value error" }
-            expect(Appsignal::Extension).to_not have_received(:set_environment_metadata)
-          end
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report on environment metadata:\n" \
-            "RuntimeError: inspect error"
-        )
-      end
-    end
-  end
-
-  describe ".report_supported_gems" do
-    it "reports about all AppSignal supported gems in the bundle using Bundler all_specs" do
-      logs = capture_logs { described_class.report_supported_gems }
-
-      expect(logs).to be_empty
-
-      unless Bundler.rubygems.respond_to?(:all_specs)
-        skip "Using new Bundler version without `all_specs` method"
-      end
-      bundle_gem_specs = silence { ::Bundler.rubygems.all_specs }
-      rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
-      rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
-      expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)
-      expect_environment_metadata("ruby_rake_version", rake_spec.version.to_s)
-      expect(rack_spec.version.to_s).to_not be_empty
-      expect(rake_spec.version.to_s).to_not be_empty
-    end
-
-    it "reports about all AppSignal supported gems in the bundle using bundler installed_specs" do
-      unless Bundler.rubygems.respond_to?(:installed_specs)
-        skip "Using old Bundler version without `installed_specs` method"
-      end
-
-      logs = capture_logs { described_class.report_supported_gems }
-
-      expect(logs).to be_empty
-
-      bundle_gem_specs = ::Bundler.rubygems.installed_specs
-      rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
-      rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
-      expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)
-      expect_environment_metadata("ruby_rake_version", rake_spec.version.to_s)
-      expect(rack_spec.version.to_s).to_not be_empty
-      expect(rake_spec.version.to_s).to_not be_empty
-    end
-
-    context "when something unforeseen errors" do
-      it "does not re-raise the error and writes it to the log" do
-        expect(Bundler).to receive(:rubygems).and_raise(RuntimeError, "bundler error")
-
-        logs = capture_logs { described_class.report_supported_gems }
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report supported gems:\nRuntimeError: bundler error"
-        )
-      end
-    end
-  end
-
-  describe ".report_enabled" do
-    it "reports a feature being enabled" do
-      logs = capture_logs { described_class.report_enabled("a_test") }
-
-      expect(logs).to be_empty
-      expect_environment_metadata("ruby_a_test_enabled", "true")
-    end
-
-    context "when something unforeseen errors" do
-      it "does not re-raise the error and writes it to the log" do
-        klass = Class.new do
-          def to_s
-            raise "to_s error"
-          end
-        end
-
-        logs = capture_logs { described_class.report_enabled(klass.new) }
-        expect(logs).to contains_log(
-          :error,
-          "Unable to report integration enabled:\nRuntimeError: to_s error"
-        )
-      end
-    end
-  end
-end

data/spec/lib/appsignal/event_formatter/action_view/render_formatter_spec.rb

@@ -1,60 +0,0 @@
-describe Appsignal::EventFormatter::ActionView::RenderFormatter do
-  let(:klass) { Appsignal::EventFormatter::ActionView::RenderFormatter }
-
-  if DependencyHelper.rails_present?
-    require "action_view"
-
-    context "when in a Rails app" do
-      let(:formatter) { klass.new }
-      before { allow(Rails.root).to receive(:to_s).and_return("/var/www/app/20130101") }
-
-      it "registers render_partial.action_view and render_template.action_view" do
-        expect(Appsignal::EventFormatter.registered?("render_partial.action_view",
-          klass)).to be_truthy
-        expect(Appsignal::EventFormatter.registered?("render_template.action_view",
-          klass)).to be_truthy
-      end
-
-      describe "#root_path" do
-        subject { formatter.root_path }
-
-        it "returns Rails root path" do
-          is_expected.to eq "/var/www/app/20130101/"
-        end
-      end
-
-      describe "#format" do
-        subject { formatter.format(payload) }
-
-        context "with an identifier" do
-          let(:payload) { { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb" } }
-
-          it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
-        end
-
-        context "with a frozen identifier" do
-          let(:payload) do
-            { :identifier => "/var/www/app/20130101/app/views/home/index/html.erb".freeze }
-          end
-
-          it { is_expected.to eq ["app/views/home/index/html.erb", nil] }
-        end
-
-        context "without an identifier" do
-          let(:payload) { {} }
-
-          it { is_expected.to be_nil }
-        end
-      end
-    end
-  else
-    context "when not in a Rails app" do
-      it "does not register the event formatter" do
-        expect(Appsignal::EventFormatter.registered?("render_partial.action_view",
-          klass)).to be_falsy
-        expect(Appsignal::EventFormatter.registered?("render_template.action_view",
-          klass)).to be_falsy
-      end
-    end
-  end
-end

data/spec/lib/appsignal/event_formatter/active_record/instantiation_formatter_spec.rb

@@ -1,21 +0,0 @@
-describe Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter do
-  let(:klass)     { Appsignal::EventFormatter::ActiveRecord::InstantiationFormatter }
-  let(:formatter) { klass.new }
-
-  it "should register instantiation.active_record" do
-    expect(Appsignal::EventFormatter.registered?("instantiation.active_record", klass)).to be_truthy
-  end
-
-  describe "#format" do
-    let(:payload) do
-      {
-        :record_count => 1,
-        :class_name => "User"
-      }
-    end
-
-    subject { formatter.format(payload) }
-
-    it { is_expected.to eq ["User", nil] }
-  end
-end

data/spec/lib/appsignal/event_formatter/active_record/sql_formatter_spec.rb

@@ -1,21 +0,0 @@
-describe Appsignal::EventFormatter::ActiveRecord::SqlFormatter do
-  let(:klass)     { described_class }
-  let(:formatter) { klass.new }
-
-  it "should register sql.active_record" do
-    expect(Appsignal::EventFormatter.registered?("sql.active_record", klass)).to be_truthy
-  end
-
-  describe "#format" do
-    let(:payload) do
-      {
-        :name => "User load",
-        :sql => "SELECT * FROM users"
-      }
-    end
-
-    subject { formatter.format(payload) }
-
-    it { is_expected.to eq ["User load", "SELECT * FROM users", 1] }
-  end
-end

data/spec/lib/appsignal/event_formatter/elastic_search/search_formatter_spec.rb

@@ -1,52 +0,0 @@
-describe Appsignal::EventFormatter::ElasticSearch::SearchFormatter do
-  let(:klass)     { Appsignal::EventFormatter::ElasticSearch::SearchFormatter }
-  let(:formatter) { klass.new }
-
-  it "should register search.elasticsearch" do
-    expect(
-      Appsignal::EventFormatter.registered?("search.elasticsearch", klass)
-    ).to be_truthy
-  end
-
-  describe "#format" do
-    let(:payload) do
-      {
-        :name => "Search",
-        :klass => "User",
-        :search => { :index => "users", :type => "user", :q => "John Doe" }
-      }
-    end
-
-    it "should return a payload with name and sanitized body" do
-      expect(formatter.format(payload)).to eql([
-        "Search: User",
-        "{:index=>\"users\", :type=>\"user\", :q=>\"?\"}"
-      ])
-    end
-  end
-
-  describe "#sanitized_search" do
-    let(:search) do
-      {
-        :index => "users",
-        :type => "user",
-        :q => "John Doe",
-        :other => "Other"
-      }
-    end
-
-    it "should sanitize non-allowlisted params" do
-      expect(
-        formatter.sanitized_search(search)
-      ).to eql(:index => "users", :type => "user", :q => "?", :other => "?")
-    end
-
-    it "should return nil string when search is nil" do
-      expect(formatter.sanitized_search(nil)).to be_nil
-    end
-
-    it "should return nil string when search is not a hash" do
-      expect(formatter.sanitized_search([])).to be_nil
-    end
-  end
-end

data/spec/lib/appsignal/event_formatter/faraday/request_formatter_spec.rb

@@ -1,21 +0,0 @@
-describe Appsignal::EventFormatter::Faraday::RequestFormatter do
-  let(:klass)     { Appsignal::EventFormatter::Faraday::RequestFormatter }
-  let(:formatter) { klass.new }
-
-  it "should register request.faraday" do
-    expect(Appsignal::EventFormatter.registered?("request.faraday", klass)).to be_truthy
-  end
-
-  describe "#format" do
-    let(:payload) do
-      {
-        :method => :get,
-        :url => URI.parse("http://example.org/hello/world?some=param")
-      }
-    end
-
-    subject { formatter.format(payload) }
-
-    it { is_expected.to eq ["GET http://example.org", "GET http://example.org/hello/world"] }
-  end
-end

data/spec/lib/appsignal/event_formatter/mongo_ruby_driver/query_formatter_spec.rb

@@ -1,84 +0,0 @@
-describe Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter do
-  let(:formatter) { Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter }
-
-  describe ".format" do
-    let(:strategy) { :find }
-    let(:command) do
-      {
-        "find" => "users",
-        "filter" => { "_id" => 1 }
-      }
-    end
-
-    it "should apply a strategy for each key" do
-      # TODO: additional curly brackets required for issue
-      # https://github.com/rspec/rspec-mocks/issues/1460
-      expect(formatter).to receive(:apply_strategy)
-        .with(:sanitize_document, { "_id" => 1 })
-      expect(formatter).to receive(:apply_strategy)
-        .with(:allow, "users")
-
-      formatter.format(strategy, command)
-    end
-
-    context "when strategy is unknown" do
-      let(:strategy) { :bananas }
-
-      it "should return an empty hash" do
-        expect(formatter.format(strategy, command)).to eql({})
-      end
-    end
-
-    context "when command is not a hash " do
-      let(:command) { :bananas }
-
-      it "should return an empty hash" do
-        expect(formatter.format(strategy, command)).to eql({})
-      end
-    end
-  end
-
-  describe ".apply_strategy" do
-    context "when strategy is allow" do
-      let(:strategy) { :allow }
-      let(:value)    { { "_id" => 1 } }
-
-      it "should return the given value" do
-        expect(formatter.apply_strategy(strategy, value)).to eql(value)
-      end
-    end
-
-    context "when strategy is sanitize_document" do
-      let(:strategy) { :sanitize_document }
-      let(:value) do
-        {
-          "_id" => 1,
-          "authors" => [
-            { "name" => "BarBaz" },
-            { "name" => "FooBar" },
-            { "name" => "BarFoo", "surname" => "Baz" }
-          ]
-        }
-      end
-
-      it "should return a sanitized document" do
-        expect(formatter.apply_strategy(strategy, value)).to eql(
-          "_id" => "?",
-          "authors" => [
-            { "name" => "?" },
-            { "name" => "?", "surname" => "?" }
-          ]
-        )
-      end
-    end
-
-    context "when strategy is missing" do
-      let(:strategy) { nil }
-      let(:value)    { { "_id" => 1 } }
-
-      it "should return a '?'" do
-        expect(formatter.apply_strategy(strategy, value)).to eql("?")
-      end
-    end
-  end
-end

data/spec/lib/appsignal/event_formatter/rom/sql_formatter_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-describe Appsignal::EventFormatter::Rom::SqlFormatter do
-  let(:klass) { described_class }
-  let(:formatter) { klass.new }
-
-  it "registers the sql event formatter" do
-    expect(Appsignal::EventFormatter.registered?("sql.dry", klass)).to be_truthy
-  end
-
-  describe "#format" do
-    let(:payload) do
-      {
-        :name => "postgres",
-        :query => "SELECT * FROM users"
-      }
-    end
-    subject { formatter.format(payload) }
-
-    it { is_expected.to eq ["query.postgres", "SELECT * FROM users", 1] }
-  end
-end

data/spec/lib/appsignal/event_formatter/sequel/sql_formatter_spec.rb

@@ -1,30 +0,0 @@
-describe Appsignal::EventFormatter::Sequel::SqlFormatter do
-  let(:klass)     { described_class }
-  let(:formatter) { klass.new }
-
-  it "registers the sql.sequel event formatter" do
-    expect(Appsignal::EventFormatter.registered?("sql.sequel", klass)).to be_truthy
-  end
-
-  describe "#format" do
-    before do
-      stub_const(
-        "SequelDatabaseTypeClass",
-        Class.new do
-          def self.to_s
-            "SequelDatabaseTypeClassToString"
-          end
-        end
-      )
-    end
-    let(:payload) do
-      {
-        :name => SequelDatabaseTypeClass,
-        :sql => "SELECT * FROM users"
-      }
-    end
-    subject { formatter.format(payload) }
-
-    it { is_expected.to eq ["SequelDatabaseTypeClassToString", "SELECT * FROM users", 1] }
-  end
-end

data/spec/lib/appsignal/event_formatter/view_component/render_formatter_spec.rb

@@ -1,41 +0,0 @@
-describe Appsignal::EventFormatter::ViewComponent::RenderFormatter do
-  let(:klass) { Appsignal::EventFormatter::ViewComponent::RenderFormatter }
-
-  if DependencyHelper.rails_present?
-    context "when in a Rails app" do
-      let(:formatter) { klass.new }
-      before { allow(Rails.root).to receive(:to_s).and_return("/var/www/app/20130101") }
-
-      it "registers render.view_component and (deprecated) !render.view_component" do
-        expect(Appsignal::EventFormatter.registered?("render.view_component",
-          klass)).to be_truthy
-        expect(Appsignal::EventFormatter.registered?("!render.view_component",
-          klass)).to be_truthy
-      end
-
-      describe "#format" do
-        subject { formatter.format(payload) }
-
-        context "with a name and identifier" do
-          let(:payload) do
-            {
-              :name => "WhateverComponent",
-              :identifier => "/var/www/app/20130101/app/components/whatever_component.rb"
-            }
-          end
-
-          it { is_expected.to eq ["WhateverComponent", "app/components/whatever_component.rb"] }
-        end
-      end
-    end
-  else
-    context "when not in a Rails app" do
-      it "does not register the event formatter" do
-        expect(Appsignal::EventFormatter.registered?("render.view_component",
-          klass)).to be_falsy
-        expect(Appsignal::EventFormatter.registered?("!render.view_component",
-          klass)).to be_falsy
-      end
-    end
-  end
-end