appsignal 2.11.10 → 3.0.0.beta.1

data/lib/appsignal/cli/notify_of_deploy.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  class CLI
-    # Command line tool to send a "Deploy Marker" for an application to
-    # AppSignal.
-    #
-    # Deploy markers are used on AppSignal.com to indicate changes in an
-    # application, "Deploy markers" indicate a deploy of an application.
-    #
-    # Incidents for exceptions and performance issues will be closed and
-    # reopened if they occur again in the new deploy.
-    #
-    # @note The same logic is used in the Capistrano integration. A deploy
-    #   marker is created on each deploy.
-    #
-    # ## Options
-    #
-    # - `--environment` required. The environment of the application being
-    #   deployed.
-    # - `--user` required. User that triggered the deploy.
-    # - `--revision` required. Git commit SHA or other identifiable revision id.
-    # - `--name` If no "name" config can be found in a `config/appsignal.yml`
-    #   file or based on the `APPSIGNAL_APP_NAME` environment variable, this
-    #   option is required.
-    #
-    # ## Exit codes
-    #
-    # - Exits with status code `0` if the deploy marker is sent.
-    # - Exits with status code `1` if the configuration is not valid and active.
-    # - Exits with status code `1` if the required options aren't present.
-    #
-    # @example basic example
-    #   appsignal notify_of_deploy \
-    #     --user=tom \
-    #     --environment=production \
-    #     --revision=abc1234
-    #
-    # @example using a custom app name
-    #   appsignal notify_of_deploy \
-    #     --user=tom \
-    #     --environment=production \
-    #     --revision=abc1234 \
-    #     --name="My app"
-    #
-    # @example help command
-    #   appsignal notify_of_deploy --help
-    #
-    # @deprecated This method of sending AppSignal deploy markers is
-    #   deprecated. Use the [`revision` config option]
-    #   (https://docs.appsignal.com/ruby/configuration/options.html#app_revision-revision)
-    #   instead. For more information, please read the [deploy markers]
-    #   (https://docs.appsignal.com/application/markers/deploy-markers.html)
-    #   documentation.
-    # @since 0.2.5
-    # @see Appsignal::Marker Appsignal::Marker
-    # @see http://docs.appsignal.com/ruby/command-line/notify_of_deploy.html
-    #   AppSignal notify_of_deploy documentation
-    # @see http://docs.appsignal.com/appsignal/terminology.html#markers
-    #   Terminology: Deploy marker
-    class NotifyOfDeploy
-      class << self
-        include Appsignal::Utils::DeprecationMessage
-
-        # @param options [Hash]
-        # @option options :environment [String] environment to load
-        #   configuration for.
-        # @option options :name [String] custom name of the application.
-        # @option options :user [String] user who triggered the deploy.
-        # @option options :revision [String] the revision that has been
-        #   deployed. E.g. a git commit SHA.
-        # @return [void]
-        def run(options)
-          config = config_for(options[:environment])
-          config[:name] = options[:name] if options[:name]
-
-          validate_active_config(config)
-          required_config = [:revision, :user]
-          required_config << :environment if config.env.empty?
-          required_config << :name if !config[:name] || config[:name].empty?
-          validate_required_options(options, required_config)
-
-          Appsignal::Marker.new(
-            {
-              :revision => options[:revision],
-              :user => options[:user]
-            },
-            config
-          ).transmit
-
-          puts
-          message = "This command (appsignal notify_of_deploy) has been " \
-            "deprecated in favor of the `revision` config option. Please " \
-            "see our documentation for more information on the recommended " \
-            "method: " \
-            "https://docs.appsignal.com/application/markers/deploy-markers.html"
-          deprecation_message message
-        end
-
-        private
-
-        def validate_required_options(options, required_options)
-          missing = required_options.select do |required_option|
-            val = options[required_option]
-            val.nil? || (val.respond_to?(:empty?) && val.empty?)
-          end
-          return unless missing.any?
-
-          puts "Error: Missing options: #{missing.join(", ")}"
-          exit 1
-        end
-
-        def validate_active_config(config)
-          return if config.active?
-
-          puts "Error: No valid config found."
-          exit 1
-        end
-
-        def config_for(environment)
-          Appsignal::Config.new(
-            Dir.pwd,
-            environment,
-            {},
-            Logger.new(StringIO.new)
-          )
-        end
-      end
-    end
-  end
-end

data/lib/appsignal/integrations/object_ruby_19.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def self.appsignal_instrument_class_method(method_name, options = {})
-    singleton_class.send \
-      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-    singleton_class.send(:define_method, method_name) do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-  end
-
-  def self.appsignal_instrument_method(method_name, options = {})
-    alias_method "appsignal_uninstrumented_#{method_name}", method_name
-    define_method method_name do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-  end
-
-  def self.appsignal_reverse_class_name
-    return "AnonymousClass" unless name
-    name.split("::").reverse.join(".")
-  end
-
-  def appsignal_reverse_class_name
-    self.class.appsignal_reverse_class_name
-  end
-end

data/lib/appsignal/integrations/object_ruby_modern.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def self.appsignal_instrument_class_method(method_name, options = {})
-    singleton_class.send \
-      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-    singleton_class.send(:define_method, method_name) do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-    if singleton_class.respond_to?(:ruby2_keywords, true)
-      singleton_class.send(:ruby2_keywords, method_name)
-    end
-  end
-
-  def self.appsignal_instrument_method(method_name, options = {})
-    alias_method "appsignal_uninstrumented_#{method_name}", method_name
-    define_method method_name do |*args, &block|
-      name = options.fetch(:name) do
-        "#{method_name}.#{appsignal_reverse_class_name}.other"
-      end
-      Appsignal.instrument name do
-        send "appsignal_uninstrumented_#{method_name}", *args, &block
-      end
-    end
-    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
-  end
-
-  def self.appsignal_reverse_class_name
-    return "AnonymousClass" unless name
-    name.split("::").reverse.join(".")
-  end
-
-  def appsignal_reverse_class_name
-    self.class.appsignal_reverse_class_name
-  end
-end

data/lib/appsignal/integrations/resque_active_job.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  module Integrations
-    # @api private
-    module ResqueActiveJobPlugin
-      def self.included(_)
-        callers = caller
-        Appsignal::Utils::DeprecationMessage.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" \
-          "#{callers.first}"
-      end
-    end
-  end
-end

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