appsignal 2.11.1-java → 3.0.0.beta.1-java

data/lib/appsignal/js_exception_transaction.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  class JSExceptionTransaction
-    attr_reader :uuid, :ext
-
-    def initialize(data)
-      @data = data
-      @uuid = SecureRandom.uuid
-      @ext = Appsignal::Extension.start_transaction(@uuid, Appsignal::Transaction::FRONTEND, 0)
-
-      set_action
-      set_metadata
-      set_error
-      set_sample_data
-    end
-
-    def set_action
-      return unless @data["action"]
-      ext.set_action(@data["action"])
-    end
-
-    def set_metadata
-      return unless @data["path"]
-      ext.set_metadata("path", @data["path"])
-    end
-
-    def set_error
-      ext.set_error(
-        @data["name"],
-        @data["message"] || "",
-        Appsignal::Utils::Data.generate(@data["backtrace"] || [])
-      )
-    end
-
-    def set_sample_data
-      {
-        :params       => @data["params"],
-        :session_data => @data["session_data"],
-        :environment  => @data["environment"],
-        :tags         => @data["tags"]
-      }.each do |key, data|
-        next unless data.is_a?(Array) || data.is_a?(Hash)
-        ext.set_sample_data(
-          key.to_s,
-          Appsignal::Utils::Data.generate(data)
-        )
-      end
-    end
-
-    def complete!
-      ext.finish(0)
-      ext.complete
-    end
-  end
-end

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/resque_active_job_spec.rb

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque_active_job"
-
-describe "Legacy Resque ActiveJob integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        include Appsignal::Integrations::ResqueActiveJobPlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResqueActiveJobPlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: include Appsignal::Integrations::ResqueActiveJobPlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

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

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque"
-
-describe "Legacy Resque integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        extend Appsignal::Integrations::ResquePlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResquePlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: extend Appsignal::Integrations::ResquePlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,128 +0,0 @@
-describe Appsignal::JSExceptionTransaction do
-  before { allow(SecureRandom).to receive(:uuid).and_return("123abc") }
-
-  let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
-  let(:data) do
-    {
-      "name"        => "TypeError",
-      "message"     => "foo is not a valid method",
-      "action"      => "ExceptionIncidentComponent",
-      "path"        => "foo.bar/moo",
-      "environment" => "development",
-      "backtrace"   => [
-        "foo.bar/js:11:1",
-        "foo.bar/js:22:2"
-      ],
-      "tags" => [
-        "tag1"
-      ]
-    }
-  end
-
-  describe "#initialize" do
-    it "should call all required methods" do
-      expect(Appsignal::Extension).to receive(:start_transaction).with("123abc", "frontend", 0).and_return(1)
-
-      expect(transaction).to receive(:set_action)
-      expect(transaction).to receive(:set_metadata)
-      expect(transaction).to receive(:set_error)
-      expect(transaction).to receive(:set_sample_data)
-
-      transaction.send :initialize, data
-
-      expect(transaction.ext).to_not be_nil
-    end
-  end
-
-  describe "#set_action" do
-    it "should call `Appsignal::Extension.set_action`" do
-      expect(transaction.ext).to receive(:set_action).with(
-        "ExceptionIncidentComponent"
-      )
-
-      transaction.set_action
-    end
-  end
-
-  describe "#set_metadata" do
-    it "should call `Appsignal::Extension.set_transaction_metadata`" do
-      expect(transaction.ext).to receive(:set_metadata).with(
-        "path",
-        "foo.bar/moo"
-      )
-
-      transaction.set_metadata
-    end
-  end
-
-  describe "#set_error" do
-    it "should call `Appsignal::Extension.set_transaction_error`" do
-      expect(transaction.ext).to receive(:set_error).with(
-        "TypeError",
-        "foo is not a valid method",
-        Appsignal::Utils::Data.generate(["foo.bar/js:11:1", "foo.bar/js:22:2"])
-      )
-
-      transaction.set_error
-    end
-  end
-
-  describe "#set_sample_data" do
-    it "should call `Appsignal::Extension.set_transaction_error_data`" do
-      expect(transaction.ext).to receive(:set_sample_data).with(
-        "tags",
-        Appsignal::Utils::Data.generate(["tag1"])
-      )
-
-      transaction.set_sample_data
-    end
-  end
-
-  context "when sending just the name" do
-    let(:data) { { "name" => "TypeError" } }
-
-    describe "#set_action" do
-      it "should not call `Appsignal::Extension.set_action`" do
-        expect(transaction.ext).to_not receive(:set_action)
-
-        transaction.set_action
-      end
-    end
-
-    describe "#set_metadata" do
-      it "should not call `Appsignal::Extension.set_transaction_metadata`" do
-        expect(transaction.ext).to_not receive(:set_metadata)
-
-        transaction.set_metadata
-      end
-    end
-
-    describe "#set_error" do
-      it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
-        expect(transaction.ext).to receive(:set_error).with(
-          "TypeError",
-          "",
-          Appsignal::Utils::Data.generate([])
-        )
-
-        transaction.set_error
-      end
-    end
-
-    describe "#set_sample_data" do
-      it "should not call `Appsignal::Extension.set_transaction_error_data`" do
-        expect(transaction.ext).to_not receive(:set_sample_data)
-
-        transaction.set_sample_data
-      end
-    end
-  end
-
-  describe "#complete!" do
-    it "should call all required methods" do
-      expect(transaction.ext).to receive(:finish).and_call_original
-      expect(transaction.ext).to receive(:complete).and_call_original
-      transaction.complete!
-    end
-  end
-end