appsignal 3.11.0 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58edd9ab16d90269a61e7e485e51078b05b60b2192461408d415eafd8327fb04
-  data.tar.gz: 92520f55157b13bbe61a98cbcc61901c3c016854a436bd4ae01ad9563d92bf9a
+  metadata.gz: c2cfb956b5058ae48109ce92cc65f4158f472797f531579e63aeb8398cb73044
+  data.tar.gz: 34ba16eb3b7c3b464e10fb9a8533d3b230cfb73550f6a804599e02b96fb909f1
 SHA512:
-  metadata.gz: 502fd7ada9029f2ecacb0368e8bfe8128fa7792031f1c567f73c05e2381aa1fbc9f946bd7b574352e0114413c724cace05758854725130101122121200ceaaff
-  data.tar.gz: 1d90ec5300a657522de4ec3298b3db22a60aadecafda35ffe38ffed72b1ae1d311e590a502ef6d002e99897f2d453e1b0c1d3c9f8569eebd9aa3d90610fce77e
+  metadata.gz: e374e9fc6cb686ec6297cb9f8025a6309f011dfc8fff3c22f32f8ddb9635e867dfd001e7058553a3f2d624bf68065e2efe2f69e73692d9b05195736992d6af63
+  data.tar.gz: e83be1622f1c5d86748bc3bb93912d79ac2dd66cb6bbe61106aee8965b3aced6c31bc5e25689f52bfa7cb01da9f10e50fb76c47de1934b93cb12b6db705bb661

data/CHANGELOG.md

@@ -1,5 +1,114 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.12.0
+
+_Published on 2024-07-22._
+
+### Added
+
+- Add a Rails configuration option to start AppSignal after Rails is initialized. By default, AppSignal will start before the Rails initializers are run. This way it is not possible to configure AppSignal in a Rails initializer using Ruby. To configure AppSignal in a Rails initializer, configure Rails to start AppSignal after it is initialized.
+
+  ```ruby
+  # config/application.rb
+
+  # ...
+
+  module MyApp
+    class Application < Rails::Application
+      # Add this line
+      config.appsignal.start_at = :after_initialize
+
+      # Other config
+    end
+  end
+  ```
+
+  Then, in the initializer:
+
+  ```ruby
+  # config/initializers/appsignal.rb
+
+  Appsignal.config = Appsignal::Config.new(
+    Rails.root,
+    Rails.env,
+    :ignore_actions => ["My action"]
+  )
+  ```
+
+  Be aware that when `start_at` is set to `after_initialize`, AppSignal will not track any errors that occur when the initializers are run and the app fails to start.
+
+  See [our Rails documentation](https://docs.appsignal.com/ruby/integrations/rails.html) for more information.
+
+  (minor [b84a6a36](https://github.com/appsignal/appsignal-ruby/commit/b84a6a3695259b365cde6f69165818a1e1b99197))
+- Add a new method of configuring AppSignal: `Appsignal.configure`. This new method allows apps to configure AppSignal in Ruby.
+
+  ```ruby
+  # The environment will be auto detected
+  Appsignal.configure do |config|
+    config.activejob_report_errors = "discard"
+    config.sidekiq_report_errors = :discard
+    config.ignore_actions = ["My ignored action", "My other ignored action"]
+    config.request_headers << "MY_HTTP_HEADER"
+    config.send_params = true
+    config.enable_host_metrics = false
+  end
+
+  # Explicitly define which environment to start
+  Appsignal.configure(:production) do |config|
+    # Some config
+  end
+  ```
+
+  This new method can be used to update config in Ruby. We still recommend to use the `config/appsignal.yml` file to configure AppSignal whenever possible. Apps that use the `Appsignal.config = Appsignal::Config.new(...)` way of configuring AppSignal, should be updated to use the new `Appsignal.configure` method. The `Appsignal::Config.new` method would overwrite the given "initial config" with the config file's config and config read from environment variables. The `Appsignal.configure` method is leading. The config file, environment variables and `Appsignal.configure` methods can all be mixed.
+
+  See [our configuration guide](https://docs.appsignal.com/ruby/configuration.html) for more information.
+
+  (minor [ba60fff9](https://github.com/appsignal/appsignal-ruby/commit/ba60fff9fa5087c78e171a0608beba882e1a4c92))
+
+### Changed
+
+- Update the Sinatra, Padrino, Grape and Hanami integration setup for applications. Before this change a "appsignal/integrations/sinatra" file would need to be required to load the AppSignal integration for Sinatra. Similar requires exist for other libraries. This has changed to a new integration load mechanism.
+
+  This new load mechanism makes starting AppSignal more predictable when loading multiple integrations, like those for Sinatra, Padrino, Grape and Hanami.
+
+  ```ruby
+  # Sinatra example
+  # Before
+  require "appsignal/integrations/sinatra"
+
+  # After
+  require "appsignal"
+
+  Appsignal.load(:sinatra)
+  Appsignal.start
+  ```
+
+  The `require "appsignal/integrations/sinatra"` will still work, but is deprecated in this release.
+
+  See the documentation for the specific libraries for the latest on how to integrate AppSignal.
+
+  - [Grape](https://docs.appsignal.com/ruby/integrations/grape.html)
+  - [Hanami](https://docs.appsignal.com/ruby/integrations/hanami.html)
+  - [Padrino](https://docs.appsignal.com/ruby/integrations/padrino.html)
+  - [Sinatra](https://docs.appsignal.com/ruby/integrations/sinatra.html)
+
+  When using a combination of the libraries listed above, read our [integration guide](https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html) on how to load and configure AppSignal for multiple integrations at once.
+
+  (minor [35fff8cb](https://github.com/appsignal/appsignal-ruby/commit/35fff8cb135bf024b3bcf95e497af7dcc0a4cc02))
+- Disable the AppSignal Rack EventHandler when AppSignal is not active. It would still trigger our instrumentation when AppSignal is not active. This reduces the instrumentation overhead when AppSignal is not active. (patch [03e7c1b2](https://github.com/appsignal/appsignal-ruby/commit/03e7c1b221caa00af1599ae94e1d4055835c94a7))
+
+### Deprecated
+
+- Deprecate the `Appsignal.config = Appsignal::Config.new(...)` method of configuring AppSignal. See the changelog entry about `Appsignal.configure { ... }` for the new way to configure AppSignal in Ruby. (minor [ba60fff9](https://github.com/appsignal/appsignal-ruby/commit/ba60fff9fa5087c78e171a0608beba882e1a4c92))
+- Deprecate the Hanami integration require: `require "appsignal/integrations/hanami"`. Use the new `Appsignal.load(:hanami)` method instead. Read our [Hanami docs](https://docs.appsignal.com/ruby/integrations/hanami.html) for more information. (patch)
+- Deprecate the Padrino integration require: `require "appsignal/integrations/padrino"`. Use the new `Appsignal.load(:padrino)` method instead. Read our [Padrino docs](https://docs.appsignal.com/ruby/integrations/padrino.html) for more information. (patch)
+- Deprecate the Sinatra integration require: `require "appsignal/integrations/sinatra"`. Use the new `Appsignal.load(:sinatra)` method instead. Read our [Sinatra docs](https://docs.appsignal.com/ruby/integrations/sinatra.html) for more information. (patch)
+- Deprecate the Grape integration require: `require "appsignal/integrations/grape"`. Use the new `Appsignal.load(:grape)` method instead. Read our [Grape docs](https://docs.appsignal.com/ruby/integrations/grape.html) for more information. (patch)
+
+### Fixed
+
+- Fix instrumentation events for response bodies appearing twice. When multiple instrumentation middleware were mounted in an application, it would create duplicate `process_response_body.rack` events. (patch [24b16517](https://github.com/appsignal/appsignal-ruby/commit/24b16517f3bf5e2911345d5d825a1febb3c7aed7))
+
 ## 3.11.0
 
 _Published on 2024-07-15._

data/Rakefile

@@ -295,7 +295,7 @@ task :console do
   require "irb/completion"
   require "appsignal"
 
-  Appsignal.config = Appsignal::Config.new(".", :console)
+  Appsignal.configure(:console)
 
   ARGV.clear
   IRB.start

data/lib/appsignal/cli/diagnose.rb

@@ -194,7 +194,7 @@ module Appsignal
             initial_config[:log_path] = current_path.join("log")
           end
 
-          Appsignal.config = Appsignal::Config.new(
+          Appsignal._config = Appsignal::Config.new(
             current_path,
             options.fetch(:environment, ENV.fetch("RACK_ENV", ENV.fetch("RAILS_ENV", nil))),
             initial_config

data/lib/appsignal/config.rb

@@ -10,6 +10,16 @@ module Appsignal
   class Config
     include Appsignal::Utils::StdoutAndLoggerMessage
 
+    # @api private
+    def self.loader_defaults
+      @loader_defaults ||= []
+    end
+
+    # @api private
+    def self.add_loader_defaults(name, options)
+      loader_defaults << [name, options]
+    end
+
     # @api private
     DEFAULT_CONFIG = {
       :activejob_report_errors => "all",
@@ -162,24 +172,14 @@ module Appsignal
     #   @return [Hash]
 
     # @api private
-    attr_reader :root_path, :env, :config_hash, :system_config,
-      :initial_config, :file_config, :env_config, :override_config
+    attr_accessor :root_path, :env, :config_hash
+    attr_reader :system_config, :initial_config, :file_config, :env_config,
+      :override_config, :dsl_config
     # @api private
     attr_accessor :logger
 
     # Initialize a new configuration object for AppSignal.
     #
-    # If this is manually initialized, and not by {Appsignal.start}, it needs
-    # to be assigned to the {Appsignal.config} attribute.
-    #
-    # @example
-    #   require "appsignal"
-    #   Appsignal.config = Appsignal::Config.new(
-    #     app_path,
-    #     "production"
-    #   )
-    #   Appsignal.start
-    #
     # @param root_path [String] Root path of the app.
     # @param env [String] The environment to load when AppSignal is started. It
     #   will look for an environment with this name in the `config/appsignal.yml`
@@ -193,55 +193,90 @@ module Appsignal
     # @param config_file [String] Custom config file location. Default
     #   `config/appsignal.yml`.
     #
+    # @api private
     # @see https://docs.appsignal.com/ruby/configuration/
     #   Configuration documentation
     # @see https://docs.appsignal.com/ruby/configuration/load-order.html
     #   Configuration load order
     # @see https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html
     #   How to integrate AppSignal manually
-    def initialize(
+    def initialize( # rubocop:disable Metrics/ParameterLists
       root_path,
-      env,
+      initial_env,
       initial_config = {},
       logger = Appsignal.internal_logger,
-      config_file = nil
+      config_file = nil,
+      load_on_new = true # rubocop:disable Style/OptionalBooleanParameter
     )
-      @config_file_error = false
       @root_path = root_path
+      @config_file_error = false
       @config_file = config_file
       @logger = logger
       @valid = false
-      @config_hash = DEFAULT_CONFIG.dup
-      env_loaded_from_initial = env.to_s
-      @env =
-        if ENV.key?("APPSIGNAL_APP_ENV")
-          env_loaded_from_env = ENV["APPSIGNAL_APP_ENV"]
-        else
-          env_loaded_from_initial
-        end
+
+      @initial_env = initial_env
+      @env = initial_env.to_s
+      @config_hash = {}
+      @system_config = {}
+      @initial_config = initial_config
+      @file_config = {}
+      @env_config = {}
+      @override_config = {}
+      @dsl_config = {} # Can be set using `Appsignal.configure`
+
+      return unless load_on_new
+
+      # Determine starting environment
+      @env = ENV["APPSIGNAL_APP_ENV"] if ENV.key?("APPSIGNAL_APP_ENV")
+      load_config
+      validate
+    end
+
+    # @api private
+    def load_config
+      # Set defaults
+      # Deep duplicate each frozen default value
+      merge(DEFAULT_CONFIG.transform_values(&:dup))
 
       # Set config based on the system
       @system_config = detect_from_system
       merge(system_config)
-      # Initial config
-      @initial_config = initial_config
+
+      # Set defaults from loaders in reverse order so the first register
+      # loader's defaults overwrite all others
+      self.class.loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
+        defaults = loader_defaults.compact.dup
+        # Overwrite root path
+        loader_path = defaults.delete(:root_path)
+        @root_path = loader_path if loader_path
+        # Overwrite env
+        loader_env = defaults.delete(:env)
+        @env = loader_env.to_s if loader_env
+        # Merge with the config loaded so far
+        merge(defaults)
+      end
+
       merge(initial_config)
+      # Track origin of env
+      @initial_config[:env] = @initial_env.to_s
+
       # Load the config file if it exists
       @file_config = load_from_disk || {}
       merge(file_config)
+
       # Load config from environment variables
       @env_config = load_from_environment
       merge(env_config)
+      # Track origin of env
+      env_loaded_from_env = ENV.fetch("APPSIGNAL_APP_ENV", nil)
+      @env_config[:env] = env_loaded_from_env if env_loaded_from_env
+
       # Load config overrides
       @override_config = determine_overrides
       merge(override_config)
+
       # Handle deprecated config options
       maintain_backwards_compatibility
-      # Validate that we have a correct config
-      validate
-      # Track origin of env
-      @initial_config[:env] = env_loaded_from_initial if env_loaded_from_initial
-      @env_config[:env] = env_loaded_from_env if env_loaded_from_env
     end
 
     # @api private
@@ -254,6 +289,7 @@ module Appsignal
       end
     end
 
+    # @api private
     def [](key)
       config_hash[key]
     end
@@ -360,6 +396,12 @@ module Appsignal
       ENV["_APP_REVISION"] = config_hash[:revision].to_s
     end
 
+    # @api private
+    def merge_dsl_options(options)
+      @dsl_options = options
+      merge(options)
+    end
+
     # @api private
     def validate
       # Strip path from endpoint so we're backwards compatible with
@@ -546,5 +588,81 @@ module Appsignal
       value = ENV.fetch("APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR", false)
       ["1", "true"].include?(value)
     end
+
+    # @api private
+    class ConfigDSL
+      attr_reader :dsl_options
+
+      def initialize(config)
+        @config = config
+        @dsl_options = {}
+      end
+
+      def app_path
+        @config.root_path
+      end
+
+      def app_path=(path)
+        @config.root_path = path
+      end
+
+      def env
+        @config.env
+      end
+
+      Appsignal::Config::ENV_STRING_KEYS.each_value do |option|
+        define_method(option) do
+          fetch_option(option)
+        end
+
+        define_method("#{option}=") do |value|
+          update_option(option, value.to_s)
+        end
+      end
+
+      Appsignal::Config::ENV_BOOLEAN_KEYS.each_value do |option|
+        define_method(option) do
+          fetch_option(option)
+        end
+
+        define_method("#{option}=") do |value|
+          update_option(option, !!value)
+        end
+      end
+
+      Appsignal::Config::ENV_ARRAY_KEYS.each_value do |option|
+        define_method(option) do
+          fetch_option(option)
+        end
+
+        define_method("#{option}=") do |value|
+          update_option(option, value.to_a)
+        end
+      end
+
+      Appsignal::Config::ENV_FLOAT_KEYS.each_value do |option|
+        define_method(option) do
+          fetch_option(option)
+        end
+
+        define_method("#{option}=") do |value|
+          update_option(option, value.to_f)
+        end
+      end
+
+      private
+
+      def fetch_option(key)
+        if @dsl_options.key?(key)
+          @dsl_options[key]
+        else
+          @dsl_options[key] = @config[key].dup
+        end
+      end
+
+      def update_option(key, value)
+        @dsl_options[key] = value
+      end
+    end
   end
 end

data/lib/appsignal/demo.rb

@@ -6,12 +6,7 @@ module Appsignal
   # {Appsignal::Demo} is a way to send demonstration / test samples for a
   # exception and a performance issue.
   #
-  # @example Loading config automatically
-  #   Appsignal::Demo.transmit
-  #
-  # @example With custom config
-  #   # If another configuration should be used, set it beforehand.
-  #   Appsignal.config = Appsignal::Config.new(Dir.pwd, "production")
+  # @example Send example transactions
   #   Appsignal::Demo.transmit
   #
   # @since 2.0.0

data/lib/appsignal/integrations/grape.rb

@@ -3,6 +3,13 @@
 require "appsignal"
 require "appsignal/rack/grape_middleware"
 
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/grape\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Grape setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/grape.html"
+)
+
 Appsignal.internal_logger.debug("Loading Grape integration")
 
 module Appsignal

data/lib/appsignal/integrations/hanami.rb

@@ -1,48 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/hanami_middleware"
 
-module Appsignal
-  module Integrations
-    # @api private
-    module HanamiPlugin
-      def self.init
-        Appsignal.internal_logger.debug("Loading Hanami integration")
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/hanami\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Hanami setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/hanami.html"
+)
 
-        hanami_app_config = ::Hanami.app.config
-
-        unless Appsignal.active?
-          Appsignal.config = Appsignal::Config.new(
-            hanami_app_config.root || Dir.pwd,
-            hanami_app_config.env
-          )
-          Appsignal.start
-        end
-
-        return unless Appsignal.active?
-
-        hanami_app_config.middleware.use(
-          ::Rack::Events,
-          [Appsignal::Rack::EventHandler.new]
-        )
-        hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
-
-        ::Hanami::Action.prepend Appsignal::Integrations::HanamiIntegration
-      end
-    end
-
-    # @api private
-    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
-
-Appsignal::Integrations::HanamiPlugin.init unless Appsignal.testing?
+Appsignal.load(:hanami)
+Appsignal.start

data/lib/appsignal/integrations/padrino.rb

@@ -1,78 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/sinatra_instrumentation"
 
-module Appsignal
-  module Integrations
-    # @api private
-    module PadrinoPlugin
-      def self.init
-        Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/padrino\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Padrino setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/padrino.html"
+)
 
-        Padrino.before_load do
-          Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
-
-          unless Appsignal.active?
-            root = Padrino.mounted_root
-            Appsignal.config = Appsignal::Config.new(root, Padrino.env)
-            Appsignal.start
-          end
-
-          next unless Appsignal.active?
-
-          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
-          Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
-            :instrument_event_name => "process_action.padrino"
-        end
-      end
-    end
-  end
-end
-
-module Appsignal
-  module Integrations
-    # @api private
-    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
-
-Appsignal::Integrations::PadrinoPlugin.init
+Appsignal.load(:padrino)
+Appsignal.start

data/lib/appsignal/integrations/railtie.rb

@@ -9,23 +9,49 @@ module Appsignal
   module Integrations
     # @api private
     class Railtie < ::Rails::Railtie
+      config.appsignal = ActiveSupport::OrderedOptions.new
+      config.appsignal.start_at = :on_load
+
+      # Run after the Rails framework is loaded
       initializer "appsignal.configure_rails_initialization" do |app|
-        Appsignal::Integrations::Railtie.initialize_appsignal(app)
+        Appsignal::Integrations::Railtie.on_load(app)
+      end
+
+      # Run after the Rails app's initializers are run
+      config.after_initialize do |app|
+        Appsignal::Integrations::Railtie.after_initialize(app)
       end
 
       console do
         Appsignal::Probes.stop
       end
 
-      def self.initialize_appsignal(app)
-        # Load config
-        Appsignal.config = Appsignal::Config.new(
-          Rails.root,
-          Rails.env,
-          :name => Appsignal::Utils::RailsHelper.detected_rails_app_name,
-          :log_path => Rails.root.join("log")
-        )
+      def self.on_load(app)
+        Appsignal::Integrations::Railtie.add_instrumentation_middleware(app)
+
+        return unless app.config.appsignal.start_at == :on_load
+
+        Appsignal::Integrations::Railtie.start
+      end
+
+      def self.after_initialize(app)
+        Appsignal::Integrations::Railtie.start if app.config.appsignal.start_at == :after_initialize
+      end
 
+      def self.start
+        unless Appsignal.config
+          Appsignal._config = Appsignal::Config.new(
+            Rails.root,
+            Rails.env,
+            :name => Appsignal::Utils::RailsHelper.detected_rails_app_name,
+            :log_path => Rails.root.join("log")
+          )
+        end
+        Appsignal.start
+        initialize_error_reporter
+      end
+
+      def self.add_instrumentation_middleware(app)
         app.middleware.insert(
           0,
           ::Rack::Events,
@@ -35,10 +61,6 @@ module Appsignal
           ActionDispatch::DebugExceptions,
           Appsignal::Rack::RailsInstrumentation
         )
-
-        Appsignal.start
-
-        initialize_error_reporter
       end
 
       def self.initialize_error_reporter

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