pg_eventstore 3.0.1 → 3.1.1

data/lib/pg_eventstore/web/metrics/collectors/subscriptions_health.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      module Collectors
+        # Liveness and error state of each reported subscription.
+        #
+        # The state column alone can not be trusted: a subscription killed without a graceful shutdown keeps
+        # state "running" and its lock forever. heartbeat_age_seconds is the discriminator - a subscription is
+        # really running only while its heartbeat stays below
+        # {PgEventstore::SubscriptionsLifecycle::HEARTBEAT_INTERVAL}.
+        class SubscriptionsHealth < Base
+          # @return [Array<PgEventstore::Web::Metrics::MetricFamily>]
+          def call
+            state = MetricFamily.new(
+              name: 'pg_eventstore_subscription_state',
+              type: 'gauge',
+              help: 'Last recorded state of the subscription. May be stale - correlate with ' \
+                    'pg_eventstore_subscription_heartbeat_age_seconds.'
+            )
+            locked = MetricFamily.new(
+              name: 'pg_eventstore_subscription_locked',
+              type: 'gauge',
+              help: 'Whether the subscription is locked by a subscriptions set.'
+            )
+            heartbeat_age = MetricFamily.new(
+              name: 'pg_eventstore_subscription_heartbeat_age_seconds',
+              type: 'gauge',
+              help: 'Seconds since the subscription row was last touched by its runner. A locked subscription ' \
+                    'with a stale heartbeat is a dead process that did not shut down gracefully.'
+            )
+            restarts = MetricFamily.new(
+              name: 'pg_eventstore_subscription_restarts_total',
+              type: 'counter',
+              help: 'Number of times the subscription was restarted after a failure.'
+            )
+            last_error_age = MetricFamily.new(
+              name: 'pg_eventstore_subscription_last_error_age_seconds',
+              type: 'gauge',
+              help: 'Seconds since the last error occurred. Absent when the subscription never failed.'
+            )
+            subscription_rows.each do |row|
+              labels = subscription_labels(row)
+              state.add_sample(labels: labels.merge(state: row['state']), value: 1)
+              locked.add_sample(labels:, value: row['locked'])
+              heartbeat_age.add_sample(labels:, value: row['heartbeat_age_seconds'])
+              restarts.add_sample(labels:, value: row['restart_count'])
+              last_error_age.add_sample(labels:, value: row['last_error_age_seconds']) if row['last_error_age_seconds']
+            end
+            [state, locked, heartbeat_age, restarts, last_error_age]
+          end
+
+          private
+
+          # @return [Array<Hash>]
+          def subscription_rows
+            builder = subscriptions_sql_builder
+            builder.select(<<~SQL)
+              s.set,
+              s.name,
+              s.state,
+              (s.locked_by is not null)::int as locked,
+              extract(epoch from ((now() at time zone 'utc') - s.updated_at))::float8 as heartbeat_age_seconds,
+              s.restart_count,
+              case when s.last_error_occurred_at is not null
+                   then extract(epoch from ((now() at time zone 'utc') - s.last_error_occurred_at))::float8
+              end as last_error_age_seconds
+            SQL
+            with_safe_conn do |conn|
+              conn.exec_params(*builder.to_exec_params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/metrics/collectors/subscriptions_latency.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      module Collectors
+        # How far behind each subscription is.
+        #
+        # A subscription checkpoint is measured in the same units as the subscription positions frontier, not in
+        # events.global_position units - the global position sequence contains gaps and runs ahead of the frontier,
+        # so comparing a checkpoint against it over-reports by orders of magnitude. Lag is therefore always measured
+        # against the frontier.
+        #
+        # - lag_events: how much of the store the subscription still has to walk through before it reaches the
+        #   frontier - that is, before it starts processing newly appended events.
+        # - lag_seconds: age of the oldest event the subscription has not processed yet; 0 when caught up.
+        #
+        # The frontier only advances while at least one subscriptions process is running. When they are all down lag
+        # stops growing - that situation is reported by the heartbeat metric of the health collector, not here.
+        class SubscriptionsLatency < Base
+          # @return [Array<PgEventstore::Web::Metrics::MetricFamily>]
+          def call
+            lag_events = MetricFamily.new(
+              name: 'pg_eventstore_subscription_lag_events',
+              type: 'gauge',
+              help: 'How many events the subscription still has to catch up on before it reaches the edge of the ' \
+                    '"all" stream.'
+            )
+            lag_seconds = MetricFamily.new(
+              name: 'pg_eventstore_subscription_lag_seconds',
+              type: 'gauge',
+              help: 'Age in seconds of the oldest event the subscription has not processed yet. 0 when caught up.'
+            )
+            frontier_position, head_global_position = *positions
+            rows = subscription_rows(frontier_position)
+            created_at_by_position = resolve_created_at(rows)
+            now = Time.now.utc
+            rows.each { add_samples(_1, created_at_by_position, now, lag_events, lag_seconds) }
+            [lag_events, lag_seconds, *store_families(frontier_position, head_global_position)]
+          end
+
+          private
+
+          # @param row [Hash]
+          # @param created_at_by_position [Hash<Integer => Time>]
+          # @param now [Time]
+          # @param lag_events [PgEventstore::Web::Metrics::MetricFamily]
+          # @param lag_seconds [PgEventstore::Web::Metrics::MetricFamily]
+          # @return [void]
+          def add_samples(row, created_at_by_position, now, lag_events, lag_seconds)
+            labels = subscription_labels(row)
+            lag_events.add_sample(labels:, value: row['lag_events'])
+            position = row['event_global_position']
+            # Caught up - nothing is left to process, so there is no unprocessed event to age. Deliberately a float:
+            # the metric is seconds everywhere else, and a gauge that renders as "0" here and "12.5" there is a wart.
+            return lag_seconds.add_sample(labels:, value: 0.0) if position.nil?
+
+            created_at = created_at_by_position[position]
+            # An unprocessed position whose event no longer exists (the event or its stream was deleted). Reporting 0
+            # would read as "caught up", the opposite of the truth, so report nothing - lag_events still carries the
+            # backlog.
+            return if created_at.nil?
+
+            lag_seconds.add_sample(labels:, value: [(now - created_at).to_f, 0].max)
+          end
+
+          # One index range scan per subscription over idx_event_subscription_positions_sposition_n_gposition. The
+          # cost does not grow with the size of the backlog: the oldest unprocessed position is taken with
+          # "order by subscription_position limit 1" rather than by aggregating over the whole backlog.
+          # @param frontier_position [Integer]
+          # @return [Array<Hash>]
+          def subscription_rows(frontier_position)
+            builder = subscriptions_sql_builder
+            builder.select(<<~SQL)
+              s.set,
+              s.name,
+              greatest(#{frontier_position} - coalesce(s.current_position, 0), 0) as lag_events,
+              next_event.global_position as event_global_position,
+              next_event.event_type_partition_id as event_type_partition_id
+            SQL
+            builder.join(<<~SQL)
+              left join lateral (
+                  select egi.global_position, egi.event_type_partition_id
+                  from event_subscription_positions esp
+                  join events_global_index egi on egi.global_position = esp.global_position
+                  where esp.subscription_position > coalesce(s.current_position, 0)
+                  order by esp.subscription_position
+                  limit 1
+                ) next_event on true
+            SQL
+            with_safe_conn do |conn|
+              conn.exec_params(*builder.to_exec_params)
+            end
+          end
+
+          # Resolves the creation time of every subscription's oldest unprocessed event.
+          #
+          # The events table is partitioned, and these events are known only by global position - which is not the
+          # partition key. Looking them up in events by global position alone would have to visit every partition and
+          # lock all of them, which stops being viable long before a store reaches five figures of partitions.
+          # events_global_index records the partition of each event, so the read API can resolve them partition-wise
+          # instead.
+          # @param subscription_rows [Array<Hash>]
+          # @return [Hash<Integer => Time>]
+          def resolve_created_at(subscription_rows)
+            indexes = subscription_rows.filter_map do |attrs|
+              next if attrs['event_global_position'].nil?
+
+              EventGlobalIndex::ReadApiRepr.new(
+                global_position: attrs['event_global_position'],
+                event_type_partition_id: attrs['event_type_partition_id']
+              )
+            end
+            return {} if indexes.empty?
+
+            resolved = events_global_index_queries.resolve_indexes(indexes, resolve_link_tos: false)
+            resolved.to_h { [_1['global_position'], _1['created_at']] }
+          end
+
+          # @return [PgEventstore::EventsGlobalIndexQueries]
+          def events_global_index_queries
+            EventsGlobalIndexQueries.new(connection, QueryStrategy::Foreground.new(connection))
+          end
+
+          # @param frontier_position [Integer]
+          # @param head_global_position [Integer]
+          # @return [Array<PgEventstore::Web::Metrics::MetricFamily>]
+          def store_families(frontier_position, head_global_position)
+            frontier = MetricFamily.new(
+              name: 'pg_eventstore_store_frontier_position',
+              type: 'gauge',
+              help: 'Latest assigned subscription position. Subscription checkpoints are measured against this.'
+            )
+            frontier.add_sample(labels: {}, value: frontier_position)
+            head = MetricFamily.new(
+              name: 'pg_eventstore_store_head_global_position',
+              type: 'gauge',
+              help: 'Global position of the newest event in the store. Contains gaps; do not compare subscription ' \
+                    'checkpoints against it.'
+            )
+            head.add_sample(labels: {}, value: head_global_position)
+            [frontier, head]
+          end
+
+          # @return [Array[Integer]]
+          def positions
+            res = with_safe_conn do |conn|
+              conn.exec(<<~SQL)
+                select
+                  (select coalesce(max(subscription_position), 0) from event_subscription_positions)
+                    as frontier_position,
+                  (select coalesce(max(global_position), 0) from events_global_index) as head_global_position
+              SQL
+            end
+            res.first.values_at('frontier_position', 'head_global_position')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/metrics/collectors/subscriptions_throughput.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      module Collectors
+        # Processing volume and speed of each reported subscription.
+        #
+        # Two deliberately different numbers:
+        # - processed_events_total is a counter; rate() over it gives the actual current throughput and correctly
+        #   drops to 0 when no matching events arrive.
+        # - capacity_events_per_second derives from the average handler execution time of the last
+        #   {PgEventstore::SubscriptionHandlerPerformance::TIMINGS_TO_KEEP} processed events - whenever they
+        #   happened. It answers "how fast can this handler go when fed", is sticky while the subscription is idle
+        #   and must not be read as current throughput.
+        class SubscriptionsThroughput < Base
+          # @return [Array<PgEventstore::Web::Metrics::MetricFamily>]
+          def call
+            processed = MetricFamily.new(
+              name: 'pg_eventstore_subscription_processed_events_total',
+              type: 'counter',
+              help: 'Total number of events processed by the subscription. Use rate() for current throughput.'
+            )
+            capacity = MetricFamily.new(
+              name: 'pg_eventstore_subscription_capacity_events_per_second',
+              type: 'gauge',
+              help: 'Average processing speed over the last few processed events, whenever they happened. ' \
+                    'Sticky while idle - this is handler capacity, not current throughput.'
+            )
+            subscription_rows.each do |row|
+              labels = subscription_labels(row)
+              processed.add_sample(labels:, value: row['total_processed_events'])
+              capacity.add_sample(labels:, value: row['capacity_eps']) if row['capacity_eps']
+            end
+            [processed, capacity]
+          end
+
+          private
+
+          # @return [Array<Hash>]
+          def subscription_rows
+            builder = subscriptions_sql_builder
+            builder.select(<<~SQL)
+              s.set,
+              s.name,
+              s.total_processed_events,
+              case when s.average_event_processing_time > 0
+                   then (1.0 / s.average_event_processing_time)::float8
+              end as capacity_eps
+            SQL
+            with_safe_conn do |conn|
+              conn.exec_params(*builder.to_exec_params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/metrics/formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      # Renders metric families into the Prometheus text exposition format (version 0.0.4).
+      class Formatter
+        # @return [String]
+        CONTENT_TYPE = 'text/plain; version=0.0.4; charset=utf-8'
+
+        # @param families [Array<PgEventstore::Web::Metrics::MetricFamily>]
+        # @return [String]
+        def call(families)
+          "#{families.map { |family| format_family(family) }.join("\n")}\n"
+        end
+
+        private
+
+        # @param family [PgEventstore::Web::Metrics::MetricFamily]
+        # @return [String]
+        def format_family(family)
+          lines = ["# HELP #{family.name} #{family.help}", "# TYPE #{family.name} #{family.type}"]
+          family.samples.each do |sample|
+            lines.push("#{family.name}#{format_labels(sample[:labels])} #{sample[:value]}")
+          end
+          lines.join("\n")
+        end
+
+        # @param labels [Hash<Symbol => String>]
+        # @return [String]
+        def format_labels(labels)
+          return '' if labels.empty?
+
+          "{#{labels.map { |name, value| %(#{name}="#{escape_label_value(value.to_s)}") }.join(',')}}"
+        end
+
+        # @param value [String]
+        # @return [String]
+        def escape_label_value(value)
+          value.gsub('\\', '\\\\\\\\').gsub("\n", '\\n').gsub('"', '\\"')
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/metrics/helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      # Route helpers of {Metrics::Application}.
+      module Helpers
+        # @param collector_classes [Array<Class<PgEventstore::Web::Metrics::Collectors::Base>>]
+        # @return [String]
+        def metrics_response(collector_classes)
+          connection = metrics_connection
+          families = collector_classes.flat_map { _1.new(connection, sets: requested_sets).call }
+          content_type(Formatter::CONTENT_TYPE)
+          Formatter.new.call(families)
+        end
+
+        # Subscription sets a scrape asks for. Accepts a repeated param ("?set=A&set=B" - what Prometheus emits for
+        # `params: {set: [A, B]}`) or a comma separated list ("?set=A,B"). Empty means every set.
+        #
+        # The query string is parsed directly because Sinatra's `params` keeps only the last value of a repeated key
+        # unless it is written as "set[]", which Prometheus does not do.
+        # @return [Array<String>]
+        def requested_sets
+          query = Rack::Utils.parse_query(request.query_string)
+          Array(query['set'] || query['set[]']).flat_map { _1.to_s.split(',') }.map(&:strip).reject(&:empty?)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/metrics/metric_family.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Metrics
+      # A collection of samples of a single Prometheus metric.
+      class MetricFamily
+        # @!attribute name
+        #   @return [String]
+        attr_reader :name
+        # @!attribute type
+        #   @return [String] "gauge" or "counter"
+        attr_reader :type
+        # @!attribute help
+        #   @return [String]
+        attr_reader :help
+        # @!attribute samples
+        #   @return [Array<Hash>]
+        attr_reader :samples
+
+        # @param name [String]
+        # @param type [String]
+        # @param help [String]
+        def initialize(name:, type:, help:)
+          @name = name
+          @type = type
+          @help = help
+          @samples = []
+        end
+
+        # @param labels [Hash<Symbol => String>]
+        # @param value [Integer, Float]
+        # @return [void]
+        def add_sample(labels:, value:)
+          @samples.push({ labels:, value: })
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/helpers.rb

@@ -30,7 +30,7 @@ module PgEventstore
 
         # @return [String]
         def first_page_link
-          path = build_path(params.slice(*(params.keys - ['starting_id'])))
+          path = url(build_path(params.slice(*(params.keys - ['starting_id']))))
           <<~HTML
             <li class="page-item">
               <a class="page-link" href="#{path}" tabindex="-1">First</a>
@@ -41,17 +41,19 @@ module PgEventstore
         # @param per_page [String] string representation of items per page. E.g. "10", "20", etc.
         # @return [String]
         def per_page_url(per_page)
-          build_path(params.merge(per_page:))
+          url(build_path(params.merge(per_page:)))
         end
 
         # @param order [String] "asc"/"desc"
         # @return [String]
         def sort_url(order)
-          build_path(params.merge(order:))
+          url(build_path(params.merge(order:)))
         end
 
+        # @param should_resolve [Boolean]
+        # @return [String]
         def resolve_link_tos_url(should_resolve)
-          build_path(params.merge(resolve_link_tos: should_resolve))
+          url(build_path(params.merge(resolve_link_tos: should_resolve)))
         end
 
         # @param number [Integer] total number of events by the current filter
@@ -82,27 +84,29 @@ module PgEventstore
 
         # @param stream [PgEventstore::Stream]
         # @return [String]
-        def stream_path(stream)
-          build_path(
-            {
-              filter: {
-                streams: [
-                  {
-                    context: escape_empty_string(stream.context),
-                    stream_name: escape_empty_string(stream.stream_name),
-                    stream_id: escape_empty_string(stream.stream_id),
-                  },
-                ],
+        def stream_url(stream)
+          url(
+            build_path(
+              {
+                filter: {
+                  streams: [
+                    {
+                      context: escape_empty_string(stream.context),
+                      stream_name: escape_empty_string(stream.stream_name),
+                      stream_id: escape_empty_string(stream.stream_id),
+                    },
+                  ],
+                },
               },
-            },
-            base_url: '/'
+              base_path: '/'
+            )
           )
         end
 
         # @param marker [String]
         # @return [String]
-        def event_marker_path(marker)
-          build_path({ filter: { markers: [escape_empty_string(marker)] } }, base_url: '/')
+        def event_marker_url(marker)
+          url(build_path({ filter: { markers: [escape_empty_string(marker)] } }, base_path: '/'))
         end
 
         # @param str [String]
@@ -120,16 +124,16 @@ module PgEventstore
         def build_starting_id_link(starting_id)
           return 'javascript: void(0);' unless starting_id
 
-          build_path(params.merge(starting_id:))
+          url(build_path(params.merge(starting_id:)))
         end
 
         # @param params [Hash, Array]
         # @return [String]
-        def build_path(params, base_url: request.path)
+        def build_path(params, base_path: request.path_info)
           encoded_params = Rack::Utils.build_nested_query(params)
-          return base_url if encoded_params.empty?
+          return base_path if encoded_params.empty?
 
-          "#{base_url}?#{encoded_params}"
+          "#{base_path}?#{encoded_params}"
         end
       end
     end

data/lib/pg_eventstore/web/views/home/partials/events.erb

@@ -12,7 +12,7 @@
     <td><%= empty_characters_fallback(h event.stream.context) %></td>
     <td><%= empty_characters_fallback(h event.stream.stream_name) %></td>
     <td>
-      <a href="<%= stream_path(event.stream) %>"><%= empty_characters_fallback(h event.stream.stream_id) %></a>
+      <a href="<%= stream_url(event.stream) %>"><%= empty_characters_fallback(h event.stream.stream_id) %></a>
       <a role="button" href="#" data-title="Copy stream definition." class="copy-to-clipboard"
          data-clipboard-content="<%= h "PgEventstore::Stream.new(context: #{event.stream.context.inspect}, stream_name: #{event.stream.stream_name.inspect}, stream_id: #{event.stream.stream_id.inspect})" %>">
         <i class="fa fa-clipboard"></i>
@@ -33,9 +33,11 @@
       <a href="javascript: void(0);" class="d-inline-block text-nowrap toggle-event-data">
         JSON <i class="fa fa-eye"></i>
       </a>
-      <a href="javascript: void(0);" class="ml-2 btn btn-danger btn-small delete-event-btn" data-global-position="<%= event.global_position %>" data-url="<%= delete_event_url(event.global_position) %>" data-toggle="modal" data-target="#delete-event-modal">
-        Delete
-      </a>
+      <% if can_delete? %>
+        <a href="javascript: void(0);" class="ml-2 btn btn-danger btn-small delete-event-btn" data-global-position="<%= event.global_position %>" data-url="<%= delete_event_url(event.global_position) %>" data-toggle="modal" data-target="#delete-event-modal">
+          Delete
+        </a>
+      <% end %>
     </td>
   </tr>
   <tr class="event-payload d-none">
@@ -55,7 +57,7 @@
               <% event.feature_markers.each do |feature_marker| %>
                 <li>
                   <%= "#{h feature_marker.description}:" if feature_marker.description %>
-                  <a href="<%= event_marker_path(feature_marker.marker) %>">
+                  <a href="<%= event_marker_url(feature_marker.marker) %>">
                     <%= empty_characters_fallback(h feature_marker.marker) %>
                   </a>
                 </li>
@@ -66,7 +68,7 @@
             Event markers
             <ul>
               <% event.markers.each do |marker| %>
-                <li> <a href="<%= event_marker_path(marker) %>"><%= empty_characters_fallback(h marker) %></a> </li>
+                <li> <a href="<%= event_marker_url(marker) %>"><%= empty_characters_fallback(h marker) %></a> </li>
               <% end %>
             </ul>
           <% end %>

data/lib/pg_eventstore/web/views/home/partials/stream_filter.erb

@@ -39,7 +39,7 @@
     <a class="btn btn-default remove-filter" href="javascript: void(0);">
       <i class="fa fa-minus-circle"></i>
     </a>
-    <% if stream[:context] && stream[:stream_name] && stream[:stream_id] %>
+    <% if stream[:context] && stream[:stream_name] && stream[:stream_id] && can_delete? %>
       <a class="btn btn-danger btn-small delete-stream" data-confirm="You are about to delete all events in <%= h stream.inspect %> stream. This action is irreversible Continue?" data-confirm-title="Delete Stream" data-method="post" href="<%= delete_stream_url(stream) %>">
         Delete stream
       </a>

data/lib/pg_eventstore/web/views/streams/partials/streams.erb

@@ -4,7 +4,7 @@
     <td><%= empty_characters_fallback(h stream.context) %></td>
     <td><%= empty_characters_fallback(h stream.stream_name) %></td>
     <td>
-      <a href="<%= stream_path(stream) %>" target="_blank"><%= empty_characters_fallback(h stream.stream_id) %></a>
+      <a href="<%= stream_url(stream) %>" target="_blank"><%= empty_characters_fallback(h stream.stream_id) %></a>
     </td>
     <td><%= stream.stream_revision %></td>
   </tr>

data/lib/pg_eventstore/web.rb

@@ -19,6 +19,14 @@ require_relative 'web/subscriptions/with_state/set_collection'
 require_relative 'web/subscriptions/with_state/subscriptions'
 require_relative 'web/subscriptions/with_state/subscriptions_set'
 require_relative 'web/subscriptions/helpers'
+require_relative 'web/metrics/metric_family'
+require_relative 'web/metrics/formatter'
+require_relative 'web/metrics/collectors/base'
+require_relative 'web/metrics/collectors/subscriptions_latency'
+require_relative 'web/metrics/collectors/subscriptions_health'
+require_relative 'web/metrics/collectors/subscriptions_throughput'
+require_relative 'web/metrics/helpers'
+require_relative 'web/metrics/application'
 require_relative 'web/application'
 
 module PgEventstore

data/rbs_collection.lock.yaml

@@ -6,7 +6,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 0cb6351d218704700cf4df797ff8966b3a418fcd
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: forwardable

data/sig/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rbs

@@ -15,7 +15,7 @@ module PgEventstore
         Integer events_number
       ) -> void
 
-    def self.update_subscription_error: (Subscription subscription, WrappedException error) -> void
+    def self.update_subscription_error: (Subscription subscription, StandardError error) -> void
 
     def self.update_subscription_chunk_stats: (Subscription subscription, Integer subscription_position) -> void
 

data/sig/pg_eventstore/subscriptions/runner_recovery_strategies/report_subscription_unrecoverable_error.rbs

@@ -0,0 +1,15 @@
+module PgEventstore
+  module RunnerRecoveryStrategies
+    class ReportSubscriptionUnrecoverableError
+      include RunnerRecoveryStrategy
+
+      @failed_subscription_notifier: _FailedSubscriptionNotifier?
+      @subscription: Subscription
+
+      def initialize: (
+          subscription: Subscription,
+          failed_subscription_notifier: _FailedSubscriptionNotifier?
+        )-> untyped
+    end
+  end
+end

data/sig/pg_eventstore/web/application.rbs

@@ -11,6 +11,8 @@ module PgEventstore
 
       def asset_url: (String path) -> String
 
+      def can_delete?: -> bool
+
       def connection: -> Connection
 
       def current_config: -> Symbol

data/sig/pg_eventstore/web/metrics/application.rbs

@@ -0,0 +1,11 @@
+module PgEventstore
+  module Web
+    module Metrics
+      class Application
+        def metrics_connection: -> Connection
+
+        def config_name: -> Symbol
+      end
+    end
+  end
+end