appsignal 2.11.8-java → 3.0.1-java

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  # @api private
-  module Rack
-    # JavaScript error catching middleware.
-    #
-    # Listens to the endpoint specified in the `frontend_error_catching_path`
-    # configuration option.
-    #
-    # This is automatically included middleware in Rails apps if the
-    # `frontend_error_catching_path` configuration option is active.
-    #
-    # If AppSignal is not active in the current environment, but does have
-    # JavaScript error catching turned on, we assume that a JavaScript script
-    # still sends errors to this endpoint. When AppSignal is not active in this
-    # scenario this middleware still listens to the endpoint, but won't record
-    # the error. It will return HTTP status code 202.
-    #
-    # @example with a Sinatra app
-    #   Sinatra::Application.use(Appsignal::Rack::JSExceptionCatcher)
-    #
-    # @see http://docs.appsignal.com/front-end/error-handling.html
-    # @api private
-    class JSExceptionCatcher
-      include Appsignal::Utils::DeprecationMessage
-
-      def initialize(app, _options = nil)
-        Appsignal.logger.debug \
-          "Initializing Appsignal::Rack::JSExceptionCatcher"
-        deprecation_message "The Appsignal::Rack::JSExceptionCatcher is " \
-          "deprecated and will be removed in a future version. Please use " \
-          "the official AppSignal JavaScript integration by disabling " \
-          "`enable_frontend_error_catching` in your configuration and " \
-          "installing AppSignal for JavaScript instead. " \
-          "(https://docs.appsignal.com/front-end/)"
-        @app = app
-      end
-
-      def call(env)
-        # Ignore other paths than the error catching path.
-        return @app.call(env) unless error_cathing_endpoint?(env)
-
-        # Prevent raising a 404 not found when a non-active environment posts
-        # to this endpoint.
-        unless Appsignal.active?
-          return [
-            202,
-            {},
-            ["AppSignal JavaScript error catching endpoint is not active."]
-          ]
-        end
-
-        begin
-          body = JSON.parse(env["rack.input"].read)
-        rescue JSON::ParserError
-          return [400, {}, ["Request payload is not valid JSON."]]
-        end
-
-        if body["name"].is_a?(String) && !body["name"].empty?
-          transaction = JSExceptionTransaction.new(body)
-          transaction.complete!
-          code = 200
-        else
-          Appsignal.logger.debug \
-            "JSExceptionCatcher: Could not send exception, 'name' is empty."
-          code = 422
-        end
-
-        [code, {}, []]
-      end
-
-      private
-
-      def error_cathing_endpoint?(env)
-        env["PATH_INFO"] == Appsignal.config[:frontend_error_catching_path]
-      end
-    end
-  end
-end

data/spec/lib/appsignal/cli/notify_of_deploy_spec.rb

@@ -1,180 +0,0 @@
-require "appsignal/cli"
-
-describe Appsignal::CLI::NotifyOfDeploy do
-  include CLIHelpers
-
-  let(:out_stream) { std_stream }
-  let(:output) { out_stream.read }
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-
-  define :include_deploy_notification do
-    match do |log|
-      log.include?("Notifying AppSignal of deploy with: ") &&
-        log.include?("AppSignal has been notified of this deploy!")
-    end
-  end
-  define :include_deploy_notification_with do |options|
-    match do |log|
-      return false unless options
-      values = "revision: #{options[:revision]}, user: #{options[:user]}"
-      log.include?("Notifying AppSignal of deploy with: #{values}") &&
-        log.include?("AppSignal has been notified of this deploy!")
-    end
-  end
-  define :include_config_error do
-    match do |log|
-      log.include? "Error: No valid config found."
-    end
-  end
-  define :include_missing_options do |options|
-    match do |log|
-      log.include? "Error: Missing options: #{options.join(", ")}"
-    end
-  end
-
-  def run
-    capture_std_streams(out_stream, err_stream) do
-      run_cli("notify_of_deploy", options)
-    end
-  end
-
-  context "without config" do
-    let(:config) { Appsignal::Config.new(tmp_dir, "production") }
-    let(:options) { {} }
-    around do |example|
-      Dir.chdir tmp_dir do
-        example.run
-      end
-    end
-
-    it "prints a config error" do
-      expect { run }.to raise_error(SystemExit)
-      expect(output).to include_config_error
-      expect(output).to_not include_deploy_notification
-    end
-  end
-
-  context "with config" do
-    let(:config) { project_fixture_config }
-    before do
-      config[:name] = options[:name] if options[:name]
-      stub_api_request config, "markers", :revision => options[:revision],
-        :user => options[:user]
-    end
-    around do |example|
-      Dir.chdir project_fixture_path do
-        example.run
-      end
-    end
-
-    context "without environment" do
-      let(:options) { { :environment => "", :revision => "foo", :user => "thijs" } }
-      before do
-        # Makes the config "active"
-        ENV["APPSIGNAL_PUSH_API_KEY"] = "foo"
-      end
-
-      it "requires environment option" do
-        expect { run }.to raise_error(SystemExit)
-        expect(output).to include_missing_options(%w[environment])
-        expect(output).to_not include_deploy_notification
-      end
-    end
-
-    context "without known environment" do
-      let(:options) { { :environment => "foo" } }
-
-      it "prints a config error" do
-        expect { run }.to raise_error(SystemExit)
-        expect(output).to include_config_error
-        expect(output).to_not include_missing_options([])
-        expect(output).to_not include_deploy_notification
-      end
-    end
-
-    context "with known environment" do
-      context "without required options" do
-        let(:options) { { :environment => "production" } }
-
-        it "prints a missing required options error" do
-          expect { run }.to raise_error(SystemExit)
-          expect(output).to_not include_config_error
-          expect(output).to include_missing_options(%w[revision user])
-          expect(output).to_not include_deploy_notification
-        end
-
-        context "with empty required option" do
-          let(:options) { { :environment => "production", :revision => "foo", :user => "" } }
-
-          it "prints a missing required option error" do
-            expect { run }.to raise_error(SystemExit)
-            expect(output).to_not include_config_error
-            expect(output).to include_missing_options(%w[user])
-            expect(output).to_not include_deploy_notification
-          end
-        end
-      end
-
-      context "with required options" do
-        let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
-        let(:log_stream) { std_stream }
-        let(:log) { log_contents(log_stream) }
-        before { Appsignal.logger = test_logger(log_stream) }
-
-        it "notifies of a deploy" do
-          run
-          expect(output).to_not include_config_error
-          expect(output).to_not include_missing_options([])
-          expect(output).to include_deploy_notification_with(options)
-        end
-
-        it "prints a deprecation message" do
-          run
-          deprecation_message = "This command (appsignal notify_of_deploy) has been deprecated"
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(log).to contains_log :warn, deprecation_message
-        end
-
-        context "with no app name configured" do
-          before { ENV["APPSIGNAL_APP_NAME"] = "" }
-
-          context "without name option" do
-            let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
-
-            it "requires name option" do
-              expect { run }.to raise_error(SystemExit)
-              expect(output).to_not include_config_error
-              expect(output).to include_missing_options(%w[name])
-              expect(output).to_not include_deploy_notification
-            end
-          end
-
-          context "with name option" do
-            let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs", :name => "foo" } }
-
-            it "notifies of a deploy with a custom name" do
-              run
-              expect(output).to_not include_config_error
-              expect(output).to_not include_missing_options([])
-              expect(output).to include_deploy_notification_with(options)
-            end
-          end
-        end
-
-        context "with name option" do
-          let(:options) do
-            { :environment => "production", :revision => "aaaaa", :user => "thijs", :name => "foo" }
-          end
-
-          it "notifies of a deploy with a custom name" do
-            run
-            expect(output).to_not include_config_error
-            expect(output).to_not include_missing_options([])
-            expect(output).to include_deploy_notification_with(options)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/appsignal/integrations/object_19_spec.rb

@@ -1,266 +0,0 @@
-require "appsignal/integrations/object"
-
-def is_ruby_19
-  RUBY_VERSION < "2.0"
-end
-
-describe Object do
-  describe "#instrument_method" do
-    context "with instance method" do
-      let(:klass) do
-        Class.new do
-          def foo(param1, options = {})
-            [param1, options]
-          end
-          appsignal_instrument_method :foo
-        end
-      end
-      let(:instance) { klass.new }
-
-      def call_with_arguments
-        instance.foo(
-          "abc",
-          :foo => "bar"
-        )
-      end
-
-      context "when active" do
-        let(:transaction) { http_request_transaction }
-        before do
-          Appsignal.config = project_fixture_config
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
-        end
-        after { Appsignal.config = nil }
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-          end
-        end
-
-        context "with named class" do
-          before do
-            class NamedClass
-              def foo
-                1
-              end
-              appsignal_instrument_method :foo
-            end
-          end
-          after { Object.send(:remove_const, :NamedClass) }
-          let(:klass) { NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
-          end
-        end
-
-        context "with nested named class" do
-          before do
-            module MyModule
-              module NestedModule
-                class NamedClass
-                  def bar
-                    2
-                  end
-                  appsignal_instrument_method :bar
-                end
-              end
-            end
-          end
-          after { Object.send(:remove_const, :MyModule) }
-          let(:klass) { MyModule::NestedModule::NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
-              Appsignal::EventFormatter::DEFAULT
-            expect(instance.bar).to eq(2)
-          end
-        end
-
-        context "with custom name" do
-          let(:klass) do
-            Class.new do
-              def foo
-                1
-              end
-              appsignal_instrument_method :foo, :name => "my_method.group"
-            end
-          end
-
-          it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
-          end
-        end
-
-        context "with a method given a block" do
-          let(:klass) do
-            Class.new do
-              def foo
-                yield
-              end
-              appsignal_instrument_method :foo
-            end
-          end
-
-          it "should yield the block" do
-            expect(instance.foo { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still calls the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(transaction).to_not receive(:start_event)
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-        end
-      end
-    end
-
-    context "with class method" do
-      let(:klass) do
-        Class.new do
-          def self.bar(param1, options = {})
-            [param1, options]
-          end
-          appsignal_instrument_class_method :bar
-        end
-      end
-      def call_with_arguments
-        klass.bar(
-          "abc",
-          :foo => "bar"
-        )
-      end
-
-      context "when active" do
-        let(:transaction) { http_request_transaction }
-        before do
-          Appsignal.config = project_fixture_config
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
-            .and_return(transaction)
-        end
-        after { Appsignal.config = nil }
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-          end
-        end
-
-        context "with named class" do
-          before do
-            class NamedClass
-              def self.bar
-                2
-              end
-              appsignal_instrument_class_method :bar
-            end
-          end
-          after { Object.send(:remove_const, :NamedClass) }
-          let(:klass) { NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
-          end
-
-          context "with nested named class" do
-            before do
-              module MyModule
-                module NestedModule
-                  class NamedClass
-                    def self.bar
-                      2
-                    end
-                    appsignal_instrument_class_method :bar
-                  end
-                end
-              end
-            end
-            after { Object.send(:remove_const, :MyModule) }
-            let(:klass) { MyModule::NestedModule::NamedClass }
-
-            it "instruments the method and calls it" do
-              expect(Appsignal.active?).to be_truthy
-              expect(transaction).to receive(:start_event)
-              expect(transaction).to receive(:finish_event).with \
-                "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
-                Appsignal::EventFormatter::DEFAULT
-              expect(klass.bar).to eq(2)
-            end
-          end
-        end
-
-        context "with custom name" do
-          let(:klass) do
-            Class.new do
-              def self.bar
-                2
-              end
-              appsignal_instrument_class_method :bar, :name => "my_method.group"
-            end
-          end
-
-          it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
-          end
-        end
-
-        context "with a method given a block" do
-          let(:klass) do
-            Class.new do
-              def self.bar
-                yield
-              end
-              appsignal_instrument_class_method :bar
-            end
-          end
-
-          it "should yield the block" do
-            expect(klass.bar { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still call the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(transaction).to_not receive(:start_event)
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-        end
-      end
-    end
-  end
-end