deployangel 0.1.29 → 0.1.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e62d94a1e10efd0431f1cfad4f7aad29f954481919a609f8112e5f517291eeb1
-  data.tar.gz: 408bcc12ae37d4f93e74e5e31ad6a8b921b30481cedf81f84055c07c62677af0
+  metadata.gz: cb73e91bc627176c422a77379e49c662588f866524d591d367f4e6e44368ee57
+  data.tar.gz: ffff6fa5fe0ce44ba2f17fb58e689eb541c5ad04549bb684ffa17d6995bc3bc4
 SHA512:
-  metadata.gz: e26a0379ee22236add3b1742a3ef174ebd3f39def909d3e230b4fadce49b1f2a3f62daa41c2aa02e05e5c12e59a78b9d6c94b7436bca9b986c56b20053f49783
-  data.tar.gz: 9d7f93900e16f63f1ba593063a31b0d03eb3f218877c65ea6c5a9b13153bd9a3520c8e5555370f8d94e53d89741f0a709143483b8ffa196e0e2e23f9a42a4b31
+  metadata.gz: e4d40abb95f27a7b2ee692016943edb4f5970edbb57aa85bd75ce66946438604863cc8ae8c8bb89d4d75f01aa8697a2cd9d496ca1393cae39b58dd4d9f9255a7
+  data.tar.gz: 4bccc9b61268107aa9948087d4b42caee50998e08060b47157f2551a0f37f8050676dac8634e5961df06e8ce5cfff8792a6287ed1b1be5d51f4e75ba169fdc92

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.1.30 (2026-10-16)
+
+- Hanami 2.2 or later: `require "deployangel/hanami"` and
+  `DeployAngel::Hanami.install(self)` in the app's class. Requests are
+  recorded by the route pattern they matched, scopes' and slices' prefixes
+  included, through a router resolver that builds on any the app configured;
+  exceptions Hanami renders as error pages count as unhandled, and the 404
+  Hanami raises for an unknown path counts as a 404. The agent starts when
+  the app boots. The metadata lists each route with its action class and the
+  paths of its action, view, and template files, and digests Hanami's layout
+  (`app/`, `slices/`, `config/`, `lib/`).
+- Sinatra 3.0 or later: `require "deployangel/sinatra"` and
+  `register DeployAngel::Sinatra`, in modular and classic apps. Requests are
+  recorded by the route Sinatra ran, with the app's mount point; exceptions
+  Sinatra renders as error pages count as unhandled. The metadata lists
+  each route with the file it's defined in.
+- The Rack base middleware asks an adapter what status a raised exception
+  will be rendered as (`raised_status`); only a 5xx counts as unhandled.
+  Rails keeps 500. It also records a request once when it passes through
+  more than one DeployAngel middleware (nested Sinatra apps, or a Sinatra
+  app mounted in Rails).
+
 ## 0.1.29 (2026-10-16)
 
 - Reports stuck work, so DeployAngel can fail a release in which a job hangs

data/README.md

@@ -1,6 +1,6 @@
-# DeployAngel for Rails
+# DeployAngel for Rails, Hanami, and Sinatra
 
-The DeployAngel agent. It watches what your Rails app does in production and
+The DeployAngel agent. It watches what your Rails, Hanami, or Sinatra app does in production and
 reports one small aggregated payload per process per minute. DeployAngel uses
 that to verify every deployment, and to tell you (or your coding agent) when a
 release is **cleared** and you can stop watching it.
@@ -20,6 +20,59 @@ Set these in production:
 DEPLOYANGEL_TOKEN=da_live_...           # an ingestion token with the telemetry scope
 ```
 
+### Hanami
+
+Requires Hanami 2.2 or later. Hanami has no Railtie, so install it where the
+app is configured:
+
+```ruby
+# config/app.rb
+require "hanami"
+require "deployangel/hanami"
+
+module Bookshelf
+  class App < Hanami::App
+    DeployAngel::Hanami.install(self)
+  end
+end
+```
+
+It names each request by the route it matched (through a router resolver that
+builds on any you've configured), records requests and the exceptions Hanami
+renders as error pages, and starts the agent when the app boots (as
+`config.ru`'s `hanami/boot` does). A process that loads the app without booting
+it, such as `hanami console`, doesn't report. Native Sidekiq jobs are recorded
+as in Rails; there's nothing else to set up for them.
+
+### Sinatra
+
+Requires Sinatra 3.0 or later. Register the extension before the app's
+routes, so it knows the file each route is defined in:
+
+```ruby
+require "sinatra/base"
+require "deployangel/sinatra"
+
+class Bookshelf < Sinatra::Base
+  register DeployAngel::Sinatra
+
+  get "/books/:id" do
+    # ...
+  end
+end
+```
+
+A classic app registers it at the top level, after `require "sinatra"`. It
+records each request by the route Sinatra ran (after `pass`, the route that
+answered), with the app's mount point from `config.ru` (`map "/api"`), and the
+exceptions Sinatra renders as error pages. A request that passes through more
+than one app (one used as another's middleware) is recorded once. File paths
+are relative to the working directory, the app's root in most deploys. An
+exception raised directly in a route block is named by its file, since the
+block has no method name, so two raised in different routes of the same file
+share a fingerprint; ones raised in helpers or other classes are told apart as
+usual.
+
 The agent must know which release it is running. It finds it in this order:
 
 1. `DEPLOYANGEL_REVISION` (the commit SHA) and `DEPLOYANGEL_RELEASE_VERSION`, if you set them
@@ -83,7 +136,8 @@ the dashboard says so.
   and a latency histogram, both per app and per route.
 - Routes are recorded as the matched pattern (`GET /users/:id`), never the raw
   path. At most 100 routes are sent per payload; the rest are folded into
-  `__other__`.
+  `__other__`. In Hanami, a request no route matched is a 404, not an
+  exception, though Hanami raises one to render it.
 - Background jobs: attempts, failed attempts, discarded jobs, duration, and
   queue latency, per job class. Works with every ActiveJob adapter (Solid
   Queue, Sidekiq, GoodJob, ...) and with native Sidekiq jobs through a server
@@ -101,9 +155,11 @@ the dashboard says so.
   job switched to. Other words are kept: `Payment failed for Jane Doe` is sent
   as it is. If your app's messages might hold personal or health data, [turn
   messages off](#exception-messages).
-- Once per process: the route table, job classes, recurring schedules
-  declared for Solid Queue, GoodJob, sidekiq-cron, sidekiq-scheduler, or
-  whenever, critical
+- Once per process: the route table (in Hanami, with each route's action
+  class and the paths of its action, view, and template files; in Sinatra,
+  with the path of the file each route is defined in), job classes,
+  recurring schedules declared for Solid Queue, GoodJob, sidekiq-cron,
+  sidekiq-scheduler, or whenever, critical
   flows, and file digests (relative paths and hashes, never file contents) so
   DeployAngel can tell which routes changed in a release.
   Disable digests with `DEPLOYANGEL_FILE_DIGESTS=false`.

data/lib/deployangel/hanami/http.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  module Hanami
+    # The Hanami adapter: route identity from DeployAngel's resolver, and the
+    # status Hanami renders a raised exception as. Everything else about
+    # recording a request is in DeployAngel::Rack::Http.
+    #
+    # Hanami renders exceptions in middleware outside the app's own, so this
+    # one sees each exception raised, before it's rendered. Hanami also
+    # raises to say a route wasn't found, and renders that as a 404, so the
+    # status comes from the same mapping Hanami uses.
+    class Http < ::DeployAngel::Rack::Http
+      def initialize(app, hanami_config = nil)
+        super(app)
+        @hanami_config = hanami_config
+      end
+
+      private
+        def route_pattern(env)
+          env[Resolver::ROUTE_PATTERN]
+        end
+
+        # config.render_error_responses, by the exception class's exact name,
+        # as Hanami reads it. Without render_errors (development, tests),
+        # the exception reaches the server, which answers 500.
+        def raised_status(_env, exception)
+          return 500 unless @hanami_config&.render_errors
+
+          status = @hanami_config.render_error_responses[exception.class.name] || :internal_server_error
+          ::Rack::Utils.status_code(status)
+        rescue StandardError
+          500
+        end
+    end
+  end
+end

data/lib/deployangel/hanami/metadata.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  module Hanami
+    # The Hanami adapter: the route table, each route's action and the files
+    # behind it, and Hanami's layout for the file digests. Schedules read on
+    # every framework, and the digests themselves, are in
+    # DeployAngel::Metadata.
+    class Metadata < ::DeployAngel::Metadata
+      DIGEST_GLOBS = %w[app/**/* slices/**/* config/**/* lib/**/* Gemfile.lock].freeze
+      SKIPPED_METHODS = %w[HEAD OPTIONS].freeze
+
+      def initialize(app:, config:, root:, environment:)
+        super(config: config, root: root, environment: environment)
+        @app = app
+      end
+
+      def digest_globs
+        DIGEST_GLOBS
+      end
+
+      # The routes as `hanami routes` lists them: a second router, built
+      # only to be inspected, whose endpoints are never resolved or called.
+      def routes
+        RouteTable.new(@app).routes.filter_map do |http_method, path, endpoint|
+          next if SKIPPED_METHODS.include?(http_method)
+
+          key = "#{http_method} #{path}"
+          next if health_check_path?(path) || @config.ignored_route?(key)
+
+          route = { "key" => key }
+          route["controller"] = endpoint[:class_name] if endpoint[:class_name]
+          files = endpoint[:files].filter_map { |file| app_relative(file) }.uniq
+          route["files"] = files unless files.empty?
+          route
+        end.uniq { |route| route["key"] }
+      rescue StandardError
+        []
+      end
+    end
+
+    # [http_method, path, endpoint] for each route, where endpoint is
+    # { class_name:, files: }: the action class and its file, view, and
+    # templates, or the file a lambda or Rack app is defined in.
+    class RouteTable
+      # Takes each route's definition from the router.
+      class Inspector
+        attr_reader :routes
+
+        def initialize
+          @routes = []
+        end
+
+        def add_route(route)
+          @routes << route
+        end
+
+        def call(*) = ""
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def routes
+        require "hanami/slice/router"
+        require "hanami/slice/routing/resolver"
+
+        targets = {}
+        inspector = Inspector.new
+        resolver = Class.new(::Hanami::Slice::Routing::Resolver) do
+          # Which slice each `to:` belongs to; nothing is resolved.
+          define_method(:call) do |path, endpoint|
+            targets[[ path.to_s, endpoint ]] ||= slice
+            ->(*) {}
+          end
+        end
+        options = { inspector: inspector, routes: @app.routes, resolver: resolver.new(slice: @app) }
+        # Hanami 3's slice router needs the app's inflector; 2.2's takes none.
+        options[:inflector] = @app.inflector if router_takes?(:inflector)
+        ::Hanami::Slice::Router.new(**options) { nil }
+
+        inspector.routes.map do |route|
+          path = route.path.to_s
+          [ route.http_method.to_s.upcase, path, endpoint(route.to, targets[[ path, route.to ]] || @app) ]
+        end
+      end
+
+      private
+        def router_takes?(keyword)
+          ::Hanami::Slice::Router.instance_method(:initialize).parameters.any? { |type, name| %i[key keyreq].include?(type) && name == keyword }
+        end
+
+        def endpoint(to, slice)
+          case to
+          when String then action(to, slice)
+          when Proc then { class_name: nil, files: [ to.source_location&.first ] }
+          when Module then { class_name: to.name, files: [ source_file(to.name) ] }
+          else { class_name: to.class.name, files: [ source_file(to.class.name) ] }
+          end
+        end
+
+        # "books.show" in a slice is its Actions::Books::Show, in
+        # app/actions/books/show.rb (slices/<name>/actions/... in a slice),
+        # rendered by the view and templates at the same name.
+        def action(key, slice)
+          parts = key.split(".")
+          name = [ slice.namespace.name, "Actions", *parts.map { |part| slice.inflector.camelize(part) } ].join("::")
+          file = source_file(name)
+          files = [ file ]
+          if file&.include?("/actions/")
+            files << file.sub("/actions/", "/views/")
+            templates = File.dirname(file.sub("/actions/", "/templates/"))
+            files.concat(Dir.glob(File.join(templates, "#{File.basename(file, ".rb")}.*")))
+          end
+          { class_name: name, files: files.compact.select { |path| File.file?(path) } }
+        end
+
+        # Loads the class (Zeitwerk autoloads it; nothing is instantiated),
+        # since a constant not loaded yet has no source location.
+        def source_file(name)
+          return unless name
+
+          Object.const_get(name)
+          Object.const_source_location(name)&.first
+        rescue NameError, StandardError
+          nil
+        end
+    end
+  end
+end

data/lib/deployangel/hanami/resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  module Hanami
+    # Hanami's router doesn't record which route a request matched, only its
+    # parameters. Its resolver, which turns each route's `to:` into an
+    # endpoint as the routes are defined, is told the route's full pattern
+    # (scopes' and slices' prefixes included), so this one wraps each
+    # endpoint to note the pattern on the request, as Rails' router does.
+    # It subclasses whatever resolver the app has configured.
+    module Resolver
+      ROUTE_PATTERN = "deployangel.route_pattern"
+
+      def self.for(base)
+        return base if base <= Tagging
+
+        Class.new(base) do
+          prepend Tagging
+
+          def self.name = "DeployAngel::Hanami::Resolver(#{superclass.name})"
+        end
+      end
+
+      module Tagging
+        def call(path, endpoint)
+          resolved = super
+          pattern = path.to_s
+          lambda do |env, *rest|
+            env[ROUTE_PATTERN] = pattern
+            resolved.call(env, *rest)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deployangel/hanami.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../deployangel"
+require_relative "hanami/resolver"
+require_relative "hanami/http"
+require_relative "hanami/metadata"
+
+module DeployAngel
+  # The Hanami integration, for Hanami 2.2 or later. Hanami has no Railtie,
+  # so the app installs it where it's configured:
+  #
+  #   # config/app.rb
+  #   require "hanami"
+  #   require "deployangel/hanami"
+  #
+  #   module Shop
+  #     class App < Hanami::App
+  #       DeployAngel::Hanami.install(self)
+  #     end
+  #   end
+  #
+  # Inside this namespace a bare Hanami means DeployAngel::Hanami, so reach
+  # for the framework itself as ::Hanami.
+  module Hanami
+    class << self
+      # Names each request's route (through the router's resolver), records
+      # requests (through the app's middleware), and starts the agent once
+      # the app boots (its container is finalized, as config.ru's
+      # hanami/boot does). Safe to call more than once.
+      def install(app)
+        @installed ||= []
+        return app if @installed.include?(app)
+
+        @installed << app
+        config = app.config
+        config.router.resolver = Resolver.for(config.router.resolver)
+        config.middleware.use(Http, config)
+        app.container.after(:finalize) { DeployAngel::Hanami.start(app) }
+        DeployAngel::Sidekiq.install
+        DeployAngel::QueueBacklog.install
+        app
+      rescue StandardError => e
+        DeployAngel.configuration.logger&.warn("DeployAngel failed to install in Hanami: #{e.class}: #{e.message}")
+        app
+      end
+
+      # Called as the app boots. The metadata goes in at start, before the
+      # reporter thread can run: the code fingerprint is built from its file
+      # digests.
+      def start(app)
+        root = app.root.to_s
+        environment = ::Hanami.env.to_s
+        DeployAngel.start(
+          environment: environment,
+          root: root,
+          framework: "hanami",
+          framework_version: (::Hanami::VERSION if defined?(::Hanami::VERSION)),
+          logger: logger(app),
+          metadata: Metadata.new(app: app, config: DeployAngel.configuration, root: root, environment: environment)
+        )
+      end
+
+      private
+        def logger(app)
+          app["logger"] if app.key?("logger")
+        rescue StandardError
+          nil
+        end
+    end
+  end
+end

data/lib/deployangel/metadata.rb

@@ -214,6 +214,21 @@ module DeployAngel
       nil
     end
 
+    # A route at a conventional health-check path ("/healthz"), left out of
+    # the route table as the request middleware leaves it out of telemetry.
+    def health_check_path?(path)
+      segments = path.to_s.split("/").reject(&:empty?)
+      Rack::Http::HEALTH_CHECK_PATHS.include?(segments.last) && segments.none? { |segment| segment.start_with?(":", "*") }
+    end
+
+    # A source file in the app, relative to its root; nil for one in a gem.
+    def app_relative(file)
+      return unless file&.start_with?("#{@root}/")
+
+      path = file.delete_prefix("#{@root}/")
+      path unless path.start_with?("vendor/", ".bundle/")
+    end
+
     # The path, or the same name with .yaml if only that exists.
     def yaml_path(path)
       [ path, path.sub(/\.yml\z/, ".yaml") ].find { |candidate| File.file?(candidate) }

data/lib/deployangel/rack/http.rb

@@ -10,7 +10,9 @@ module DeployAngel
     # An adapter subclasses it, answers route_pattern (and rendered_exception
     # if the framework renders exceptions itself), and is inserted at the top
     # of the stack, so it sees the final status after the framework's own
-    # error pages. DeployAngel::Rails::Http is the Rails adapter.
+    # error pages. A framework that renders exceptions outside its app
+    # middleware instead answers raised_status. DeployAngel::Rails::Http and
+    # DeployAngel::Hanami::Http are the adapters.
     #
     # A request is only counted against a route pattern the framework
     # matched, never the raw path, which keeps IDs out of route keys.
@@ -26,9 +28,16 @@ module DeployAngel
         @app = app
       end
 
+      # Set on a request once a DeployAngel middleware records it. Apps nest
+      # (a Sinatra app used as another's middleware, or mounted inside
+      # Rails), so a request can pass through more than one; only the
+      # outermost records it.
+      RECORDED = "deployangel.recorded"
+
       def call(env)
-        return @app.call(env) unless DeployAngel.recording?
+        return @app.call(env) if !DeployAngel.recording? || env[RECORDED]
 
+        env[RECORDED] = true
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         Redaction.request_host = env["HTTP_HOST"]
         # Checkpoints recorded from here until the app returns count as
@@ -37,7 +46,10 @@ module DeployAngel
         begin
           status, headers, body = @app.call(env)
         rescue Exception => e # rubocop:disable Lint/RescueException -- recorded, then re-raised untouched
-          record(env, 500, started, unhandled: true, exception: e)
+          # A framework that renders exceptions outside this middleware turns
+          # some into a 4xx; only one that ends in a 5xx is unhandled.
+          status = raised_status(env, e)
+          record(env, status, started, unhandled: status >= 500, exception: (e if status >= 500))
           raise
         ensure
           ExecutionContext.restore(previous_context)
@@ -65,6 +77,12 @@ module DeployAngel
           nil
         end
 
+        # The status a raised exception will be rendered as, by a framework
+        # that renders it after this middleware. 500 unless an adapter knows.
+        def raised_status(_env, _exception)
+          500
+        end
+
         def route_key(env)
           pattern = route_pattern(env) or return nil
 

data/lib/deployangel/sinatra/http.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  module Sinatra
+    # The Sinatra adapter: route identity from the route Sinatra matched,
+    # with the app's mount point, and the exceptions Sinatra renders itself.
+    # Everything else about recording a request is in DeployAngel::Rack::Http.
+    class Http < ::DeployAngel::Rack::Http
+      def initialize(app, sinatra_app = nil)
+        super(app)
+        @sinatra_app = sinatra_app
+      end
+
+      private
+        # Sinatra names the route it ran ("GET /books/:id"), the last one when
+        # a route passes, but not the mount point (SCRIPT_NAME), which
+        # Sinatra strips from the path it matches.
+        def route_pattern(env)
+          route = env["sinatra.route"] or return nil
+
+          pattern = route.split(" ", 2).last
+          mount = env["SCRIPT_NAME"].to_s.chomp("/")
+          note_mount(mount) unless mount.empty?
+          "#{mount}#{pattern}"
+        end
+
+        # Sinatra rescues an exception, renders its error page, and keeps the
+        # exception here.
+        def rendered_exception(env)
+          env["sinatra.error"]
+        end
+
+        def note_mount(mount)
+          DeployAngel::Sinatra.mounts[@sinatra_app] ||= mount if @sinatra_app
+        rescue StandardError
+          nil
+        end
+    end
+  end
+end

data/lib/deployangel/sinatra/metadata.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DeployAngel
+  module Sinatra
+    # The Sinatra adapter: the route table of every app that registered the
+    # extension, with each route's file, and a typical Sinatra layout for the
+    # file digests. Schedules read on every framework, and the digests
+    # themselves, are in DeployAngel::Metadata.
+    class Metadata < ::DeployAngel::Metadata
+      DIGEST_GLOBS = %w[*.rb *.ru app/**/* lib/**/* config/**/* routes/**/* views/**/* models/**/* helpers/**/*
+                        controllers/**/* db/migrate/**/* Gemfile.lock].freeze
+      SKIPPED_METHODS = %w[HEAD OPTIONS].freeze
+
+      def digest_globs
+        DIGEST_GLOBS
+      end
+
+      def routes
+        DeployAngel::Sinatra.apps.flat_map { |app| app_routes(app) }
+          .uniq { |route| route["key"] }
+      rescue StandardError
+        []
+      end
+
+      private
+        def app_routes(app)
+          mount = DeployAngel::Sinatra.mounts[app].to_s
+          app.routes.flat_map do |verb, signatures|
+            next [] if SKIPPED_METHODS.include?(verb)
+
+            signatures.filter_map do |pattern, *|
+              path = pattern.to_s
+              key = "#{verb} #{mount}#{path}"
+              next if health_check_path?(path) || @config.ignored_route?(key)
+
+              route = { "key" => key }
+              files = Array(DeployAngel::Sinatra.route_files[[ verb, path ]]).filter_map { |file| app_relative(file) }.uniq
+              route["files"] = files unless files.empty?
+              route
+            end
+          end
+        rescue StandardError
+          []
+        end
+
+    end
+  end
+end

data/lib/deployangel/sinatra.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../deployangel"
+require_relative "sinatra/http"
+require_relative "sinatra/metadata"
+
+module DeployAngel
+  # The Sinatra integration, for Sinatra 3.0 or later, as an extension:
+  #
+  #   require "sinatra/base"
+  #   require "deployangel/sinatra"
+  #
+  #   class Bookshelf < Sinatra::Base
+  #     register DeployAngel::Sinatra
+  #     # routes after it, so their files are known
+  #   end
+  #
+  # A classic app registers it at the top level, after `require "sinatra"`.
+  # Inside this namespace a bare Sinatra means DeployAngel::Sinatra, so reach
+  # for the framework itself as ::Sinatra.
+  module Sinatra
+    class << self
+      # The apps that registered the extension, and each route's file, by
+      # [verb, path]: Sinatra hands an extension each route's own block as
+      # it's defined, while the route table holds only Sinatra's wrapper.
+      def apps
+        @apps ||= []
+      end
+
+      def route_files
+        @route_files ||= {}
+      end
+
+      # Where each app was mounted (a map "/api" in config.ru), as its
+      # requests show it, since the routes it declares don't include it.
+      def mounts
+        @mounts ||= {}
+      end
+
+      # Records the app's requests (through its middleware) and starts the
+      # agent, once per process.
+      def registered(app)
+        return if apps.include?(app)
+
+        apps << app
+        app.use(Http, app)
+        DeployAngel::Sidekiq.install
+        DeployAngel::QueueBacklog.install
+        start(app) unless DeployAngel.agent
+      rescue StandardError => e
+        DeployAngel.configuration.logger&.warn("DeployAngel failed to install in Sinatra: #{e.class}: #{e.message}")
+      end
+
+      def route_added(verb, path, block)
+        file = block&.source_location&.first
+        (route_files[[ verb.to_s, path.to_s ]] ||= []) << file if file
+      rescue StandardError
+        nil
+      end
+
+      # The metadata goes in at start, before the reporter thread can run:
+      # the code fingerprint is built from its file digests. The working
+      # directory is the app's root, as in most deploys.
+      def start(app)
+        root = Dir.pwd
+        environment = app.environment.to_s
+        DeployAngel.start(
+          environment: environment,
+          root: root,
+          framework: "sinatra",
+          framework_version: (::Sinatra::VERSION if defined?(::Sinatra::VERSION)),
+          metadata: Metadata.new(config: DeployAngel.configuration, root: root, environment: environment)
+        )
+      end
+    end
+  end
+end

data/lib/deployangel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeployAngel
-  VERSION = "0.1.29"
+  VERSION = "0.1.30"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployangel
 version: !ruby/object:Gem::Version
-  version: 0.1.29
+  version: 0.1.30
 platform: ruby
 authors:
 - Jordan Owens
@@ -51,6 +51,10 @@ files:
 - lib/deployangel/doctor.rb
 - lib/deployangel/exerciser.rb
 - lib/deployangel/fork_hook.rb
+- lib/deployangel/hanami.rb
+- lib/deployangel/hanami/http.rb
+- lib/deployangel/hanami/metadata.rb
+- lib/deployangel/hanami/resolver.rb
 - lib/deployangel/mcp.rb
 - lib/deployangel/metadata.rb
 - lib/deployangel/queue_backlog.rb
@@ -61,6 +65,9 @@ files:
 - lib/deployangel/rails/metadata.rb
 - lib/deployangel/rails/railtie.rb
 - lib/deployangel/sidekiq.rb
+- lib/deployangel/sinatra.rb
+- lib/deployangel/sinatra/http.rb
+- lib/deployangel/sinatra/metadata.rb
 - lib/deployangel/tasks.rb
 - lib/deployangel/verification_waiter.rb
 - lib/deployangel/version.rb
@@ -90,5 +97,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: 'DeployAngel agent for Rails: production verification for every deployment.'
+summary: 'DeployAngel agent for Rails, Hanami, and Sinatra: production verification
+  for every deployment.'
 test_files: []