appsignal 3.11.0-java → 3.12.1-java

data/lib/appsignal/integrations/sinatra.rb

@@ -1,24 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/sinatra_instrumentation"
 
-Appsignal.internal_logger.debug("Loading Sinatra (#{Sinatra::VERSION}) integration")
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/sinatra\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Sinatra setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/sinatra.html"
+)
 
-unless Appsignal.active?
-  app_settings = ::Sinatra::Application.settings
-  Appsignal.config = Appsignal::Config.new(
-    app_settings.root || Dir.pwd,
-    app_settings.environment
-  )
-
-  Appsignal.start
-end
-
-if Appsignal.active?
-  ::Sinatra::Base.use(
-    ::Rack::Events,
-    [Appsignal::Rack::EventHandler.new]
-  )
-  ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
-end
+Appsignal.load(:sinatra)
+Appsignal.start

data/lib/appsignal/loaders/grape.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class GrapeLoader < Loader
+      register :grape
+
+      def on_load
+        require "appsignal/rack/grape_middleware"
+      end
+    end
+  end
+end

data/lib/appsignal/loaders/hanami.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class HanamiLoader < Loader
+      register :hanami
+
+      def on_load
+        hanami_app_config = ::Hanami.app.config
+        register_config_defaults(
+          :root_path => hanami_app_config.root.to_s,
+          :env => hanami_app_config.env
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/hanami_middleware"
+
+        hanami_app_config = ::Hanami.app.config
+        hanami_app_config.middleware.use(
+          ::Rack::Events,
+          [Appsignal::Rack::EventHandler.new]
+        )
+        hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
+
+        ::Hanami::Action.prepend Appsignal::Loaders::HanamiLoader::HanamiIntegration
+      end
+
+      module HanamiIntegration
+        def call(env)
+          super
+        ensure
+          transaction = env[::Appsignal::Rack::APPSIGNAL_TRANSACTION]
+
+          transaction&.set_action_if_nil(self.class.name)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/loaders/padrino.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class PadrinoLoader < Loader
+      register :padrino
+
+      def on_load
+        register_config_defaults(
+          :root_path => Padrino.mounted_root,
+          :env => Padrino.env
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/sinatra_instrumentation"
+
+        Padrino::Application.prepend(Appsignal::Loaders::PadrinoLoader::PadrinoIntegration)
+
+        Padrino.before_load do
+          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+          Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
+            :instrument_event_name => "process_action.padrino"
+        end
+      end
+
+      module PadrinoIntegration
+        def route!(base = settings, pass_block = nil)
+          return super if !Appsignal.active? || env["sinatra.static_file"]
+
+          begin
+            super
+          ensure
+            transaction = Appsignal::Transaction.current
+            transaction.set_action_if_nil(get_payload_action(request))
+          end
+        end
+
+        private
+
+        def get_payload_action(request)
+          # Short-circuit is there's no request object to obtain information from
+          return settings.name.to_s unless request
+
+          # Newer versions expose the action / controller on the request class.
+          # Newer versions also still expose a route_obj so we must prioritize the
+          # action/fullpath methods.
+          # The `request.action` and `request.controller` values are `nil` when a
+          # endpoint is not found, `""` if not specified by the user.
+          controller_name = request.controller if request.respond_to?(:controller)
+          action_name = request.action if request.respond_to?(:action)
+          action_name ||= ""
+
+          return "#{settings.name}:#{controller_name}##{action_name}" unless action_name.empty?
+
+          # Older versions of Padrino work with a route object
+          if request.respond_to?(:route_obj) && request.route_obj
+            return "#{settings.name}:#{request.route_obj.original_path}"
+          end
+
+          # Fall back to the application name if we haven't found an action name in
+          # any previous methods.
+          "#{settings.name}#unknown"
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/loaders/sinatra.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class SinatraLoader < Loader
+      register :sinatra
+
+      def on_load
+        app_settings = ::Sinatra::Application.settings
+        register_config_defaults(
+          :root_path => app_settings.root,
+          :env => app_settings.environment
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/sinatra_instrumentation"
+
+        ::Sinatra::Base.use(::Rack::Events, [Appsignal::Rack::EventHandler.new])
+        ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
+      end
+    end
+  end
+end

data/lib/appsignal/loaders.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # @api private
+  module Loaders
+    class << self
+      def loaders
+        @loaders ||= {}
+      end
+
+      def instances
+        @instances ||= {}
+      end
+
+      def register(name, klass)
+        loaders[name.to_sym] = klass
+      end
+
+      def registered?(name)
+        loaders.key?(name)
+      end
+
+      def unregister(name)
+        loaders.delete(name)
+      end
+
+      def load(name_str)
+        name = name_str.to_sym
+
+        unless registered?(name)
+          require_loader(name)
+          unless registered?(name)
+            Appsignal.internal_logger
+              .warn("No loader found with the name '#{name}'.")
+            return
+          end
+        end
+
+        Appsignal.internal_logger.debug("Loading '#{name}' loader")
+
+        begin
+          loader_klass = loaders[name]
+          loader = loader_klass.new
+          instances[name] = loader
+          loader.on_load if loader.respond_to?(:on_load)
+        rescue => e
+          Appsignal.internal_logger.error(
+            "An error occurred while loading the '#{name}' loader: " \
+              "#{e.class}: #{e.message}\n#{e.backtrace}"
+          )
+        end
+      end
+
+      def start
+        instances.each do |name, instance|
+          Appsignal.internal_logger.debug("Starting '#{name}' loader")
+          begin
+            instance.on_start if instance.respond_to?(:on_start)
+          rescue => e
+            Appsignal.internal_logger.error(
+              "An error occurred while starting the '#{name}' loader: " \
+                "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+            )
+          end
+        end
+      end
+
+      private
+
+      def require_loader(name)
+        require "appsignal/loaders/#{name}"
+      rescue LoadError
+        nil
+      end
+    end
+
+    class Loader
+      class << self
+        attr_reader :loader_name
+
+        def register(name)
+          @loader_name = name
+          Loaders.register(name, self)
+        end
+      end
+
+      def register_config_defaults(options)
+        Appsignal::Config.add_loader_defaults(self.class.loader_name, options)
+      end
+    end
+  end
+end

data/lib/appsignal/rack/abstract_middleware.rb

@@ -91,9 +91,10 @@ module Appsignal
       def call_app(env, transaction)
         status, headers, obody = @app.call(env)
         body =
-          if obody.is_a? Appsignal::Rack::BodyWrapper
+          if env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED]
             obody
           else
+            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
             # Instrument response body and closing of the response body
             Appsignal::Rack::BodyWrapper.wrap(obody, transaction)
           end

data/lib/appsignal/rack/event_handler.rb

@@ -2,11 +2,6 @@
 
 module Appsignal
   module Rack
-    APPSIGNAL_TRANSACTION = "appsignal.transaction"
-    APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
-    APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
-    RACK_AFTER_REPLY = "rack.after_reply"
-
     # Instrumentation middleware using Rack's Events module.
     #
     # We recommend using this in combination with the
@@ -56,6 +51,8 @@ module Appsignal
 
       # @api private
       def on_start(request, _response)
+        return unless Appsignal.active?
+
         event_handler = self
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_start") do
           request.env[APPSIGNAL_EVENT_HANDLER_ID] ||= id
@@ -90,6 +87,8 @@ module Appsignal
 
       # @api private
       def on_error(request, _response, error)
+        return unless Appsignal.active?
+
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
@@ -103,6 +102,7 @@ module Appsignal
 
       # @api private
       def on_finish(request, response)
+        return unless Appsignal.active?
         return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
         transaction = request.env[APPSIGNAL_TRANSACTION]

data/lib/appsignal/rack.rb

@@ -3,6 +3,12 @@
 module Appsignal
   # @api private
   module Rack
+    APPSIGNAL_TRANSACTION = "appsignal.transaction"
+    APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
+    APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
+    APPSIGNAL_RESPONSE_INSTRUMENTED = "appsignal.response_instrumentation_active"
+    RACK_AFTER_REPLY = "rack.after_reply"
+
     class Utils
       # Fetch the queue start time from the request environment.
       #

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.11.0"
+  VERSION = "3.12.1"
 end

data/lib/appsignal.rb

@@ -22,8 +22,8 @@ module Appsignal
     include Helpers::Instrumentation
     include Helpers::Metrics
 
-    # Accessor for the AppSignal configuration.
-    # Return the current AppSignal configuration.
+    # The loaded AppSignal configuration.
+    # Returns the current AppSignal configuration.
     #
     # Can return `nil` if no configuration has been set or automatically loaded
     # by an automatic integration or by calling {.start}.
@@ -31,12 +31,31 @@ module Appsignal
     # @example
     #   Appsignal.config
     #
-    # @example Setting the configuration
-    #   Appsignal.config = Appsignal::Config.new(Dir.pwd, "production")
-    #
     # @return [Config, nil]
+    # @see configure
+    # @see Config
+    attr_reader :config
+
+    # Set the AppSignal config.
+    #
+    # @deprecated Use {Appsignal.configure} instead.
+    # @param conf [Appsignal::Config]
+    # @return [void]
     # @see Config
-    attr_accessor :config
+    def config=(conf)
+      Appsignal::Utils::StdoutAndLoggerMessage.warning \
+        "Configuring AppSignal with `Appsignal.config=` is deprecated. " \
+          "Use `Appsignal.configure { |config| ... }` to configure AppSignal. " \
+          "https://docs.appsignal.com/ruby/configuration.html\n" \
+          "#{caller.first}"
+      @config = conf
+    end
+
+    # @api private
+    def _config=(conf)
+      @config = conf
+    end
+
     # Accessor for toggle if the AppSignal C-extension is loaded.
     #
     # Can be `nil` if extension has not been loaded yet. See
@@ -87,7 +106,9 @@ module Appsignal
     #   Appsignal.start
     #
     # @example with custom loaded configuration
-    #   Appsignal.config = Appsignal::Config.new(Dir.pwd, "production")
+    #   Appsignal.configure(:production) do |config|
+    #     config.ignore_actions = ["My action"]
+    #   end
     #   Appsignal.start
     #
     # @return [void]
@@ -109,11 +130,13 @@ module Appsignal
 
       if config.valid?
         if config.active?
+          @started = true
           internal_logger.info "Starting AppSignal #{Appsignal::VERSION} " \
             "(#{$PROGRAM_NAME}, Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM})"
           config.write_to_environment
           Appsignal::Extension.start
           Appsignal::Hooks.load_hooks
+          Appsignal::Loaders.start
 
           if config[:enable_allocation_tracking] && !Appsignal::System.jruby?
             Appsignal::Extension.install_allocation_event_hook
@@ -147,14 +170,102 @@ module Appsignal
     # @since 1.0.0
     def stop(called_by = nil)
       if called_by
-        internal_logger.debug("Stopping appsignal (#{called_by})")
+        internal_logger.debug("Stopping AppSignal (#{called_by})")
       else
-        internal_logger.debug("Stopping appsignal")
+        internal_logger.debug("Stopping AppSignal")
       end
       Appsignal::Extension.stop
       Appsignal::Probes.stop
     end
 
+    # Configure the AppSignal Ruby gem using a DSL.
+    #
+    # Pass a block to the configure method to configure the Ruby gem.
+    #
+    # Each config option defined in our docs can be fetched, set and modified
+    # via a helper method in the given block.
+    #
+    # After AppSignal has started using {start}, the configuration can not be
+    # modified. Any calls to this helper will be ignored.
+    #
+    # This helper should not be used to configure multiple environments, like
+    # done in the YAML file. Configure the environment you want active when the
+    # application starts.
+    #
+    # @example Configure AppSignal for the application
+    #   Appsignal.configure do |config|
+    #     config.path = "/the/app/path"
+    #     config.active = ENV["APP_ACTIVE"] == "true"
+    #     config.push_api_key = File.read("appsignal_key.txt").chomp
+    #     config.ignore_actions = ENDPOINTS.select { |e| e.public? }.map(&:name)
+    #     config.request_headers << "MY_CUSTOM_HEADER"
+    #   end
+    #
+    # @example Configure AppSignal for the application and select the environment
+    #   Appsignal.configure(:production) do |config|
+    #     config.active = true
+    #   end
+    #
+    # @example Automatically detects the app environment
+    #   # Tries to determine the app environment automatically from the
+    #   # environment and the libraries it integrates with.
+    #   ENV["RACK_ENV"] = "production"
+    #
+    #   Appsignal.configure do |config|
+    #     config.env # => "production"
+    #   end
+    #
+    # @example Calling configure multiple times for different environments resets the configuration
+    #   Appsignal.configure(:development) do |config|
+    #     config.ignore_actions = ["My action"]
+    #   end
+    #
+    #   Appsignal.configure(:production) do |config|
+    #     config.ignore_actions # => []
+    #   end
+    #
+    # @example Load config without a block
+    #   # This will require either ENV vars being set
+    #   # or the config/appsignal.yml being present
+    #   Appsignal.configure
+    #   # Or for the environment given as an argument
+    #   Appsignal.configure(:production)
+    #
+    # @yield [Config] Gives the {Config} instance to the block.
+    # @return [void]
+    # @see config
+    # @see Config
+    # @see https://docs.appsignal.com/ruby/configuration.html Configuration guide
+    # @see https://docs.appsignal.com/ruby/configuration/options.html Configuration options
+    def configure(env = nil)
+      if Appsignal.started?
+        Appsignal.internal_logger
+          .warn("AppSignal is already started. Ignoring `Appsignal.configure` call.")
+        return
+      end
+
+      if config && config.env == env.to_s
+        config
+      else
+        self._config = Appsignal::Config.new(
+          Dir.pwd,
+          env || ENV["APPSIGNAL_APP_ENV"] || ENV["RAILS_ENV"] || ENV.fetch("RACK_ENV", nil),
+          {},
+          Appsignal.internal_logger,
+          nil,
+          false
+        )
+        config.load_config
+      end
+
+      config_dsl = Appsignal::Config::ConfigDSL.new(config)
+      if block_given?
+        yield config_dsl
+        config.merge_dsl_options(config_dsl.dsl_options)
+      end
+      config.validate
+    end
+
     def forked
       return unless active?
 
@@ -163,6 +274,38 @@ module Appsignal
       Appsignal::Extension.start
     end
 
+    # Load an AppSignal integration.
+    #
+    # Load one of the supported integrations via our loader system.
+    # This will set config defaults and integratie with the library if
+    # AppSignal is active upon start.
+    #
+    # @example Load Sinatra integrations
+    #   # First load the integration
+    #   Appsignal.load(:sinatra)
+    #   # Start AppSignal
+    #   Appsignal.start
+    #
+    # @example Load Sinatra integrations and define custom config
+    #   # First load the integration
+    #   Appsignal.load(:sinatra)
+    #
+    #   # Customize config
+    #   Appsignal.configure do |config|
+    #     config.ignore_actions = ["GET /ping"]
+    #   end
+    #
+    #
+    #   # Start AppSignal
+    #   Appsignal.start
+    #
+    # @param integration_name [String, Symbol] Name of the integration to load.
+    # @return [void]
+    # @since 3.12.0
+    def load(integration_name)
+      Loaders.load(integration_name)
+    end
+
     # @api private
     def get_server_state(key)
       Appsignal::Extension.get_server_state(key)
@@ -238,6 +381,16 @@ module Appsignal
       !!extension_loaded
     end
 
+    # Returns if {.start} has been called before with a valid config to start
+    # AppSignal.
+    #
+    # @return [Boolean]
+    # @see Extension
+    # @since 3.12.0
+    def started?
+      defined?(@started) ? @started : false
+    end
+
     # Returns the active state of the AppSignal integration.
     #
     # Conditions apply for AppSignal to be marked as active:
@@ -314,6 +467,7 @@ module Appsignal
   end
 end
 
+require "appsignal/loaders"
 require "appsignal/environment"
 require "appsignal/system"
 require "appsignal/utils"

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

@@ -13,7 +13,6 @@ describe Appsignal::CLI::Demo do
     ENV.delete("RACK_ENV")
     stub_api_request config, "auth"
   end
-  after { Appsignal.config = nil }
 
   def run
     run_within_dir project_fixture_path

data/spec/lib/appsignal/cli/diagnose/paths_spec.rb

@@ -4,7 +4,7 @@ require "appsignal/cli/diagnose/paths"
 
 describe Appsignal::CLI::Diagnose::Paths do
   describe "#paths" do
-    before { Appsignal.config = project_fixture_config }
+    before { start_agent }
 
     it "returns gem installation path as package_install_path" do
       expect(described_class.new.paths[:package_install_path]).to eq(

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

@@ -67,7 +67,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       capture_diagnatics_report_request
     end
     before(:send_report => :no_cli_option) { options["no-send-report"] = nil }
-    after { Appsignal.config = nil }
 
     def capture_diagnatics_report_request
       stub_diagnostics_report_request.to_rack(DiagnosticsReportEndpoint)