pg_eventstore 1.4.0 → 1.5.0

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -6,11 +6,8 @@ module PgEventstore
   class SubscriptionFeeder
     extend Forwardable
 
-    # @return [Integer] number of seconds between heartbeat updates
-    HEARTBEAT_INTERVAL = 10 # seconds
-
-    def_delegators :subscriptions_set, :id
     def_delegators :@basic_runner, :start, :stop, :restore, :state, :wait_for_finish, :stop_async
+    def_delegators :@subscriptions_lifecycle, :force_lock!
 
     # @param config_name [Symbol]
     # @param set_name [String]
@@ -18,23 +15,27 @@ module PgEventstore
     # @param retries_interval [Integer] a delay between retries of failed SubscriptionsSet
     def initialize(config_name:, set_name:, max_retries:, retries_interval:)
       @config_name = config_name
-      @runners = []
-      @subscriptions_set_attrs = {
-        name: set_name, max_restarts_number: max_retries, time_between_restarts: retries_interval
-      }
-      @commands_handler = CommandsHandler.new(@config_name, self, @runners)
       @basic_runner = BasicRunner.new(0.2, 0)
-      @force_lock = false
-      @subscriptions_pinged_at = Time.at(0)
+      @subscriptions_set_lifecycle = SubscriptionsSetLifecycle.new(
+        @config_name,
+        { name: set_name, max_restarts_number: max_retries, time_between_restarts: retries_interval }
+      )
+      @subscriptions_lifecycle = SubscriptionsLifecycle.new(@config_name, @subscriptions_set_lifecycle)
+      @commands_handler = CommandsHandler.new(@config_name, self, @subscriptions_lifecycle.runners)
       attach_runner_callbacks
     end
 
+    # @return [Integer]
+    def id
+      @subscriptions_set_lifecycle.persisted_subscriptions_set.id
+    end
+
     # Adds SubscriptionRunner to the set
     # @param runner [PgEventstore::SubscriptionRunner]
     # @return [PgEventstore::SubscriptionRunner]
     def add(runner)
       assert_proper_state!
-      @runners.push(runner)
+      @subscriptions_lifecycle.runners.push(runner)
       runner
     end
 
@@ -43,7 +44,7 @@ module PgEventstore
     def start_all
       return self unless @basic_runner.running?
 
-      @runners.each(&:start)
+      @subscriptions_lifecycle.runners.each(&:start)
       self
     end
 
@@ -52,135 +53,85 @@ module PgEventstore
     def stop_all
       return self unless @basic_runner.running?
 
-      @runners.each(&:stop_async)
+      @subscriptions_lifecycle.runners.each(&:stop_async)
       self
     end
 
-    # Sets the force_lock flash to true. If set - all related Subscriptions will ignore their lock state and will be
-    # locked by the new SubscriptionsSet.
-    # @return [void]
-    def force_lock!
-      @force_lock = true
-    end
-
     # Produces a copy of currently running Subscriptions. This is needed, because original Subscriptions objects are
     # dangerous to use - users may incidentally break their state.
     # @return [Array<PgEventstore::Subscription>]
     def read_only_subscriptions
-      @runners.map(&:subscription).map(&:dup)
+      @subscriptions_lifecycle.subscriptions.map(&:dup)
     end
 
     # Produces a copy of current SubscriptionsSet. This is needed, because original SubscriptionsSet object is
     # dangerous to use - users may incidentally break its state.
     # @return [PgEventstore::SubscriptionsSet, nil]
     def read_only_subscriptions_set
-      @subscriptions_set&.dup
+      @subscriptions_set_lifecycle.subscriptions_set&.dup
     end
 
     private
 
-    # Locks all Subscriptions behind the current SubscriptionsSet
-    # @return [void]
-    def lock_all
-      @runners.each { |runner| runner.lock!(subscriptions_set.id, force: @force_lock) }
-    end
-
-    # @return [PgEventstore::SubscriptionsSet]
-    def subscriptions_set
-      @subscriptions_set ||= SubscriptionsSet.using_connection(@config_name).create(**@subscriptions_set_attrs)
-    end
-
-    # @return [PgEventstore::SubscriptionRunnersFeeder]
-    def feeder
-      SubscriptionRunnersFeeder.new(@config_name)
-    end
-
     # @return [void]
     def attach_runner_callbacks
-      @basic_runner.define_callback(:change_state, :after, method(:update_subscriptions_set_state))
-      @basic_runner.define_callback(:before_runner_started, :before, method(:before_runner_started))
-      @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
-      @basic_runner.define_callback(:after_runner_died, :after, method(:restart_runner))
-      @basic_runner.define_callback(:process_async, :before, method(:ping_subscriptions_set))
-      @basic_runner.define_callback(:process_async, :before, method(:process_async))
-      @basic_runner.define_callback(:process_async, :after, method(:ping_subscriptions))
-      @basic_runner.define_callback(:after_runner_stopped, :before, method(:after_runner_stopped))
-      @basic_runner.define_callback(:before_runner_restored, :after, method(:update_runner_restarts))
-    end
-
-    # @return [void]
-    def before_runner_started
-      lock_all
-      @runners.each(&:start)
-      @commands_handler.start
-    rescue PgEventstore::SubscriptionAlreadyLockedError
-      @subscriptions_set&.delete
-      @subscriptions_set = nil
-      raise
-    end
-
-    # @param error [StandardError]
-    # @return [void]
-    def after_runner_died(error)
-      subscriptions_set.update(last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc)
-    end
-
-    # @param _error [StandardError]
-    # @return [void]
-    def restart_runner(_error)
-      return if subscriptions_set.restart_count >= subscriptions_set.max_restarts_number
-
-      Thread.new do
-        sleep subscriptions_set.time_between_restarts
-        restore
-      end
-    end
-
-    # @return [void]
-    def update_runner_restarts
-      subscriptions_set.update(last_restarted_at: Time.now.utc, restart_count: subscriptions_set.restart_count + 1)
-    end
-
-    # @return [void]
-    def process_async
-      feeder.feed(@runners)
-    end
-
-    # @return [void]
-    def ping_subscriptions_set
-      return if subscriptions_set.updated_at > Time.now.utc - HEARTBEAT_INTERVAL
-
-      subscriptions_set.update(updated_at: Time.now.utc)
-    end
-
-    # @return [void]
-    def ping_subscriptions
-      return if @subscriptions_pinged_at > Time.now.utc - HEARTBEAT_INTERVAL
-
-      runners = @runners.select do |runner|
-        next false unless runner.running?
-
-        runner.subscription.updated_at < Time.now.utc - HEARTBEAT_INTERVAL
-      end
-      unless runners.empty?
-        Subscription.using_connection(@config_name).ping_all(subscriptions_set.id, runners.map(&:subscription))
-      end
-
-      @subscriptions_pinged_at = Time.now.utc
-    end
-
-    # @return [void]
-    def after_runner_stopped
-      @runners.each(&:stop_async).each(&:wait_for_finish)
-      @subscriptions_set&.delete
-      @subscriptions_set = nil
-      @commands_handler.stop
-    end
-
-    # @param state [String]
-    # @return [void]
-    def update_subscriptions_set_state(state)
-      subscriptions_set.update(state: state)
+      @basic_runner.define_callback(
+        :change_state, :after,
+        SubscriptionFeederHandlers.setup_handler(:update_subscriptions_set_state, @subscriptions_set_lifecycle)
+      )
+
+      @basic_runner.define_callback(
+        :before_runner_started, :before,
+        SubscriptionFeederHandlers.setup_handler(:lock_subscriptions, @subscriptions_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :before_runner_started, :before,
+        SubscriptionFeederHandlers.setup_handler(:start_runners, @subscriptions_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :before_runner_started, :before,
+        SubscriptionFeederHandlers.setup_handler(:start_cmds_handler, @commands_handler)
+      )
+
+      @basic_runner.define_callback(
+        :after_runner_died, :before,
+        SubscriptionFeederHandlers.setup_handler(:persist_error_info, @subscriptions_set_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :after_runner_died, :before,
+        SubscriptionFeederHandlers.setup_handler(:restart_runner, @subscriptions_set_lifecycle, @basic_runner)
+      )
+
+      @basic_runner.define_callback(
+        :process_async, :before,
+        SubscriptionFeederHandlers.setup_handler(:ping_subscriptions_set, @subscriptions_set_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :process_async, :before,
+        SubscriptionFeederHandlers.setup_handler(:feed_runners, @subscriptions_lifecycle, @config_name)
+      )
+      @basic_runner.define_callback(
+        :process_async, :after,
+        SubscriptionFeederHandlers.setup_handler(:ping_subscriptions, @subscriptions_lifecycle)
+      )
+
+      @basic_runner.define_callback(
+        :after_runner_stopped, :before,
+        SubscriptionFeederHandlers.setup_handler(:stop_runners, @subscriptions_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :after_runner_stopped, :before,
+        SubscriptionFeederHandlers.setup_handler(:reset_subscriptions_set, @subscriptions_set_lifecycle)
+      )
+      @basic_runner.define_callback(
+        :after_runner_stopped, :before,
+        SubscriptionFeederHandlers.setup_handler(:stop_commands_handler, @commands_handler)
+      )
+
+      @basic_runner.define_callback(
+        :before_runner_restored, :after,
+        SubscriptionFeederHandlers.setup_handler(:update_subscriptions_set_restarts, @subscriptions_set_lifecycle)
+      )
     end
 
     # This method helps to ensure that no Subscription is added after SubscriptionFeeder's runner is working
@@ -188,10 +139,11 @@ module PgEventstore
     # @raise [RuntimeError]
     def assert_proper_state!
       return if @basic_runner.initial? || @basic_runner.stopped?
+      subscriptions_set = @subscriptions_set_lifecycle.persisted_subscriptions_set
 
       error_message = <<~TEXT
-        Could not add subscription - #{subscriptions_set.name}##{subscriptions_set.id} must be either in the initial \
-        or in the stopped state, but it is in the #{@basic_runner.state} state now.
+        Could not add subscription - #{subscriptions_set.name}##{subscriptions_set.id} must be \
+        either in the initial or in the stopped state, but it is in the #{@basic_runner.state} state now.
       TEXT
       raise error_message
     end

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -74,66 +74,41 @@ module PgEventstore
 
     # @return [void]
     def attach_callbacks
-      @events_processor.define_callback(:process, :around, method(:track_exec_time))
-      @events_processor.define_callback(:process, :after, method(:update_subscription_stats))
-      @events_processor.define_callback(:error, :after, method(:update_subscription_error))
-      @events_processor.define_callback(:error, :after, method(:restart_subscription))
-      @events_processor.define_callback(:feed, :after, method(:update_subscription_chunk_stats))
-      @events_processor.define_callback(:restart, :after, method(:update_subscription_restarts))
-      @events_processor.define_callback(:change_state, :after, method(:update_subscription_state))
-    end
-
-    # @param action [Proc]
-    # @return [void]
-    def track_exec_time(action, *)
-      @stats.track_exec_time { action.call }
-    end
-
-    # @param current_position [Integer]
-    # @return [void]
-    def update_subscription_stats(current_position)
-      @subscription.update(
-        average_event_processing_time: @stats.average_event_processing_time,
-        current_position: current_position,
-        total_processed_events: @subscription.total_processed_events + 1
+      @events_processor.define_callback(
+        :process, :around,
+        SubscriptionRunnerHandlers.setup_handler(:track_exec_time, @stats)
+      )
+      @events_processor.define_callback(
+        :process, :after,
+        SubscriptionRunnerHandlers.setup_handler(:update_subscription_stats, @subscription, @stats)
       )
-    end
-
-    # @param state [String]
-    # @return [void]
-    def update_subscription_state(state)
-      @subscription.update(state: state)
-    end
 
-    # @return [void]
-    def update_subscription_restarts
-      @subscription.update(last_restarted_at: Time.now.utc, restart_count: @subscription.restart_count + 1)
-    end
+      @events_processor.define_callback(
+        :error, :after,
+        SubscriptionRunnerHandlers.setup_handler(:update_subscription_error, @subscription)
+      )
+      @events_processor.define_callback(
+        :error, :after,
+        SubscriptionRunnerHandlers.setup_handler(
+          :restart_events_processor,
+          @subscription, @restart_terminator, @failed_subscription_notifier, @events_processor
+        )
+      )
 
-    # @param error [StandardError]
-    # @return [void]
-    def update_subscription_error(error)
-      @subscription.update(last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc)
-    end
+      @events_processor.define_callback(
+        :feed, :after,
+        SubscriptionRunnerHandlers.setup_handler(:update_subscription_chunk_stats, @subscription)
+      )
 
-    # @param global_position [Integer]
-    # @return [void]
-    def update_subscription_chunk_stats(global_position)
-      @subscription.update(last_chunk_fed_at: Time.now.utc, last_chunk_greatest_position: global_position)
-    end
+      @events_processor.define_callback(
+        :restart, :after,
+        SubscriptionRunnerHandlers.setup_handler(:update_subscription_restarts, @subscription)
+      )
 
-    # @param error [StandardError]
-    # @return [void]
-    def restart_subscription(error)
-      return if @restart_terminator&.call(@subscription.dup)
-      if @subscription.restart_count >= @subscription.max_restarts_number
-        return @failed_subscription_notifier&.call(@subscription.dup, error)
-      end
-
-      Thread.new do
-        sleep @subscription.time_between_restarts
-        restore
-      end
+      @events_processor.define_callback(
+        :change_state, :after,
+        SubscriptionRunnerHandlers.setup_handler(:update_subscription_state, @subscription)
+      )
     end
   end
 end

data/lib/pg_eventstore/subscriptions/subscriptions_lifecycle.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionsLifecycle
+    extend Forwardable
+
+    # @return [Integer] number of seconds between heartbeat updates
+    HEARTBEAT_INTERVAL = 10 # seconds
+
+    # @!attribute runners
+    #   @return [Array<PgEventstore::SubscriptionRunner>]
+    attr_reader :runners
+
+    # @param config_name [Symbol]
+    # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+    def initialize(config_name, subscriptions_set_lifecycle)
+      @config_name = config_name
+      @subscriptions_set_lifecycle = subscriptions_set_lifecycle
+      @runners = []
+      @subscriptions_pinged_at = Time.at(0)
+      @force_lock = false
+    end
+
+    # Locks all Subscriptions behind the current SubscriptionsSet
+    # @return [void]
+    def lock_all
+      @runners.each do |runner|
+        runner.lock!(@subscriptions_set_lifecycle.persisted_subscriptions_set.id, force: force_locked?)
+      end
+    rescue PgEventstore::SubscriptionAlreadyLockedError
+      @subscriptions_set_lifecycle.reset_subscriptions_set
+      raise
+    end
+
+    # @return [void]
+    def ping_subscriptions
+      return if @subscriptions_pinged_at > Time.now.utc - HEARTBEAT_INTERVAL
+
+      runners = @runners.select do |runner|
+        next false unless runner.running?
+
+        runner.subscription.updated_at < Time.now.utc - HEARTBEAT_INTERVAL
+      end
+      unless runners.empty?
+        Subscription.using_connection(@config_name).ping_all(
+          @subscriptions_set_lifecycle.persisted_subscriptions_set.id, runners.map(&:subscription)
+        )
+      end
+
+      @subscriptions_pinged_at = Time.now.utc
+    end
+
+    # @return [Array<PgEventstore::Subscription>]
+    def subscriptions
+      @runners.map(&:subscription)
+    end
+
+    # Sets the force_lock flag to true. If set - all related Subscriptions will ignore their lock state and will be
+    # locked by the new SubscriptionsSet.
+    # @return [void]
+    def force_lock!
+      @force_lock = true
+    end
+
+    # @return [Boolean]
+    def force_locked?
+      @force_lock
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -9,6 +9,12 @@ require_relative 'subscription_handler_performance'
 require_relative 'subscription_runner'
 require_relative 'subscriptions_set'
 require_relative 'subscription_runners_feeder'
+require_relative 'subscriptions_set_lifecycle'
+require_relative 'subscriptions_lifecycle'
+require_relative 'callback_handlers/subscription_feeder_handlers'
+require_relative 'callback_handlers/subscription_runner_handlers'
+require_relative 'callback_handlers/events_processor_handlers'
+require_relative 'callback_handlers/commands_handler_handlers'
 require_relative 'subscription_feeder'
 require_relative 'extensions/command_class_lookup_extension'
 require_relative 'extensions/base_command_extension'
@@ -84,7 +90,7 @@ module PgEventstore
       runner = SubscriptionRunner.new(
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(
-          create_event_handler(middlewares, handler), graceful_shutdown_timeout: graceful_shutdown_timeout
+          create_raw_event_handler(middlewares, handler), graceful_shutdown_timeout: graceful_shutdown_timeout
         ),
         subscription: subscription,
         restart_terminator: restart_terminator,
@@ -118,7 +124,7 @@ module PgEventstore
     # @param middlewares [Array<Symbol>, nil]
     # @param handler [#call]
     # @return [Proc]
-    def create_event_handler(middlewares, handler)
+    def create_raw_event_handler(middlewares, handler)
       deserializer = EventDeserializer.new(select_middlewares(middlewares), config.event_class_resolver)
       ->(raw_event) { handler.call(deserializer.deserialize(raw_event)) }
     end

data/lib/pg_eventstore/subscriptions/subscriptions_set_lifecycle.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionsSetLifecycle
+    # @return [Integer] number of seconds between heartbeat updates
+    HEARTBEAT_INTERVAL = 10 # seconds
+
+    # @!attribute subscriptions_set
+    #   @return [PgEventstore::SubscriptionsSet, nil]
+    attr_reader :subscriptions_set
+
+    # @param config_name [Symbol]
+    # @param subscriptions_set_attrs [Hash]
+    def initialize(config_name, subscriptions_set_attrs)
+      @config_name = config_name
+      @subscriptions_set_attrs = subscriptions_set_attrs
+      @subscriptions_set_pinged_at = Time.at(0)
+    end
+
+    # @return [void]
+    def ping_subscriptions_set
+      return if @subscriptions_set_pinged_at > Time.now.utc - HEARTBEAT_INTERVAL
+
+      persisted_subscriptions_set.update(updated_at: Time.now.utc)
+      @subscriptions_set_pinged_at = Time.now.utc
+    end
+
+    # @return [PgEventstore::SubscriptionsSet]
+    def persisted_subscriptions_set
+      @subscriptions_set ||= SubscriptionsSet.using_connection(@config_name).create(**@subscriptions_set_attrs)
+    end
+
+    # @return [void]
+    def reset_subscriptions_set
+      @subscriptions_set&.delete
+      @subscriptions_set = nil
+    end
+  end
+end

data/lib/pg_eventstore/utils.rb

@@ -61,6 +61,14 @@ module PgEventstore
         str.gsub!(/[A-Z]/) { |letter| '_' + letter.downcase }
         str
       end
+
+      # Detect the global position of the event record in the database. If it is a link event - we pick a
+      # global_position of the link instead of picking a global_position of an event this link points to.
+      # @param raw_event [Hash]
+      # @return [Integer]
+      def original_global_position(raw_event)
+        raw_event['link'] ? raw_event['link']['global_position'] : raw_event['global_position']
+      end
     end
   end
 end

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/lib/pg_eventstore/web/application.rb

@@ -69,6 +69,11 @@ module PgEventstore
         def asset_url(path)
           url("#{path}?v=#{PgEventstore::VERSION}")
         end
+
+        # @return [Boolean]
+        def resolve_link_tos?
+          params.key?(:resolve_link_tos) ? params[:resolve_link_tos] == 'true' : true
+        end
       end
 
       get '/' do
@@ -77,7 +82,10 @@ module PgEventstore
           starting_id: params[:starting_id]&.to_i,
           per_page: Paginator::EventsCollection::PER_PAGE[params[:per_page]],
           order: Paginator::EventsCollection::SQL_DIRECTIONS[params[:order]],
-          options: { filter: { event_types: events_filter, streams: streams_filter } }
+          options: {
+            filter: { event_types: events_filter, streams: streams_filter },
+            resolve_link_tos: resolve_link_tos?
+          }
         )
 
         if request.xhr?

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

@@ -23,9 +23,7 @@ module PgEventstore
         def collection
           @_collection ||= PgEventstore.client(config_name).read(
             PgEventstore::Stream.all_stream,
-            options: options.merge(
-              from_position: starting_id, max_count: per_page, direction: order, resolve_link_tos: true
-            ),
+            options: options.merge(from_position: starting_id, max_count: per_page, direction: order),
             middlewares: []
           )
         end

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

@@ -50,6 +50,10 @@ module PgEventstore
           build_path(params.merge(order: order))
         end
 
+        def resolve_link_tos_url(should_resolve)
+          build_path(params.merge(resolve_link_tos: should_resolve))
+        end
+
         # @param number [Integer] total number of events by the current filter
         # @return [String]
         def total_count(number)
@@ -92,7 +96,6 @@ module PgEventstore
               }
             }
           )
-
         end
 
         private

data/lib/pg_eventstore/web/public/javascripts/pg_eventstore.js

@@ -113,12 +113,12 @@ $(function(){
         initEventTypeFilterAutocomplete($(this));
     });
 
+    // Automatically refresh events list every two seconds
     let autoRefreshInterval;
     $('#auto-refresh').change(function(){
        if($(this).is(':checked')) {
            autoRefreshInterval = setInterval(function(){
                $.getJSON(window.location.href).success(function(response, textStatus, xhr){
-                   console.log(textStatus);
                    if(textStatus === 'success') {
                        $('#events-table').find('tbody').html(response.events);
                        $('#total-count').html(response.total_count);
@@ -131,6 +131,15 @@ $(function(){
        }
     });
 
+    // Resolve links checkbox
+    $('#resolve-link-tos').change(function(){
+        if($(this).is(':checked')) {
+            window.location.href = $(this).data('url-checked');
+        } else {
+            window.location.href = $(this).data('url-unchecked');
+        }
+    });
+
     // Toggle event's JSON data/metadata details
     $('#events-table').on('click', '.toggle-event-data', function(){
         $(this).parents('tr').next().toggleClass('d-none');

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

@@ -78,13 +78,12 @@ module PgEventstore
         # @param state [String]
         # @param updated_at [Time]
         # @return [String] html status
-        def colored_state(state, updated_at)
+        def colored_state(state, interval, updated_at)
           if state == RunnerState::STATES[:running]
             # -1 is added as a margin to prevent false-positive result
-            if updated_at < Time.now.utc - SubscriptionFeeder::HEARTBEAT_INTERVAL - 1
+            if updated_at < Time.now.utc - interval - 1
               title = <<~TEXT
-                Something is wrong. Last update was more than #{SubscriptionFeeder::HEARTBEAT_INTERVAL} seconds \
-                ago(#{updated_at}).
+                Something is wrong. Last update was more than #{interval} seconds ago(#{updated_at}).
               TEXT
               <<~HTML
                 <span class="text-warning text-nowrap">

data/lib/pg_eventstore/web/views/home/dashboard.erb

@@ -26,6 +26,7 @@
             <br/>
             <form id="filters-form" action="<%= url('/') %>" method="GET" data-parsley-validate class="form-horizontal form-label-left">
               <input type="hidden" name="per_page" value="<%= params[:per_page].to_i %>">
+              <input type="hidden" name="resolve_link_tos" value="<%= resolve_link_tos? %>">
               <div class="stream-filters">
                 <% streams_filter&.each do |attrs| %>
                   <%= erb :'home/partials/stream_filter', { layout: false }, { stream: attrs } %>
@@ -89,6 +90,16 @@
                     <button type="submit" class="d-none"></button>
                   </div>
                 </form>
+                <div class="float-md-right mt-2 mr-2">
+                  <div class="form-group">
+                    <div class="checkbox">
+                      <label for="resolve-link-tos" class="control-label">
+                        Resolve links
+                        <input type="checkbox" id="resolve-link-tos" value="true" autocomplete="off" <% if resolve_link_tos? %> checked <% end %> data-url-checked="<%= resolve_link_tos_url(true) %>" data-url-unchecked="<%= resolve_link_tos_url(false) %>">
+                      </label>
+                    </div>
+                  </div>
+                </div>
                 <div class="float-md-right mt-2 mr-2">
                   <div class="form-group">
                     <div class="checkbox">