gitlab-triage 1.51.1 → 1.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0852608feca48b98d92771b30203ae3f2a83220fdcce24f08d435b9af12c7f20'
-  data.tar.gz: 224da2c7b14a0513d2d06c43ae1c13bb3ac5459114df3daa32da6785354b2247
+  metadata.gz: e4b12c328cc4c5a865ceca6ccadd49a8dedc1066564fa62a28718c3b164f3a15
+  data.tar.gz: 1298d537c79ef8d74f3816e18d482a8bbee02fde1b3a1717869709795f40f547
 SHA512:
-  metadata.gz: 435c98010e80f7bf81e31a0976c36d948e56e2b94da2e08ad9eefef5f6680967ab95c4e91f9667233111d564de27c5380890f546d047e6b1cf55a7c6e6915881
-  data.tar.gz: 9e87b898dab83aee3b7f0585e805a6200478e27fc7cefa441b99422666d7ee51b85819b5e04812542b3e0d6a136384409a0261f7971d97571606d3a369fabc26
+  metadata.gz: c8d68d1f8162e2324685ee874a862429569f76d4a060d138f922f1b4866b57eabfc9420f72a6da68f28f0285669542169f6b7294f785e6152c3075c36280bf40
+  data.tar.gz: aaf7e8821f7cbfc9112c2f25776566c7775276c5eeebaccd43dedcee686824cce2db97ee813648504274befd5db4696f4e816afb6bab83d72039e2cfa7e13437

data/.rubocop_todo.yml

@@ -6,13 +6,15 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 78
+# Offense count: 81
 CodeReuse/ActiveRecord:
   Exclude:
+    - 'lib/gitlab/triage/action/work_item.rb'
     - 'lib/gitlab/triage/engine.rb'
     - 'lib/gitlab/triage/filters/base_conditions_filter.rb'
     - 'lib/gitlab/triage/filters/member_conditions_filter.rb'
     - 'lib/gitlab/triage/graphql_network.rb'
+    - 'lib/gitlab/triage/normalizers/work_item_normalizer.rb'
     - 'lib/gitlab/triage/validators/limiter_validator.rb'
     - 'spec/gitlab/triage/action_spec.rb'
     - 'spec/gitlab/triage/engine_spec.rb'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab-triage (1.51.1)
+    gitlab-triage (1.53.0)
       activesupport (>= 5.1)
       globalid (~> 1.0, >= 1.0.1)
       graphql (< 2.1.0)

data/README.md

@@ -50,6 +50,7 @@ Select which resource to add the policy to:
 - `issues`
 - `merge_requests`
 - `branches`
+- `work_items` (see [Work items policy type](#work-items-policy-type))
 
 And create an array of `rules` to define your policies:
 
@@ -148,6 +149,107 @@ We're enforcing multiple polices with pipeline schedules at [triage-ops](
 https://gitlab.com/gitlab-org/quality/triage-ops), where we're also
 extensively utilizing the [plugins system](#can-i-customize).
 
+### Work items policy type
+
+The `work_items` policy type fetches and updates resources through the
+[Work Items REST API](https://docs.gitlab.com/api/work_items/) instead of the
+legacy issues REST API. The legacy issues API cannot see custom work item
+types; the `work_items` type can, which lets you triage work items of any type,
+including namespace-defined custom types.
+
+> **Warning:** The Work Items REST API is currently behind the
+`:work_item_rest_api` feature flag and is pre-GA. The `work_items` policy type
+only works on instances where that API is available and enabled, and its
+surface may change before GA. It is not yet a stable contract for external
+users. Treat this policy type as experimental until the API reaches GA.
+
+> **Note:** A `404` or `403` from the list endpoint (feature flag off, or
+insufficient access) raises a clear error rather than silently matching zero
+resources.
+
+Example:
+
+```yml
+resource_rules:
+  work_items:
+    rules:
+      - name: Triage new bugs
+        conditions:
+          type: Bug
+          state: opened
+          labels:
+            - needs-triage
+        actions:
+          assignees:
+            - my-username
+          labels:
+            - triaged
+```
+
+#### Supported conditions
+
+- `type` - match work item types by name, including custom types. Maps to the
+  `work_item_type_names` filter (case-insensitive, server-side).
+- `state` - `opened` or `closed`.
+- `status` - custom work item status name (for example `In progress`).
+  Enterprise Edition only.
+- `labels` / `forbidden_labels` - label names to require or exclude.
+- `assignees` - assignee usernames.
+- `date` - `created_at` / `updated_at` staleness (same shape as the
+  [date condition](#date-condition)).
+
+#### Supported actions
+
+- `labels` - add labels by name. If any requested label does not exist, the
+  automation stops immediately (matching the `labels` action on the `issues`
+  type) rather than applying nothing.
+- `assignees` - set assignees by username. If any requested username does not
+  exist, the automation stops immediately rather than sending an empty
+  assignee set (which would unassign everyone).
+- `comment` - **not yet supported.** The Work Items REST API does not yet
+  provide a note-create endpoint (tracked in
+  [gitlab-org/gitlab#604028](https://gitlab.com/gitlab-org/gitlab/-/work_items/604028)).
+  A `comment` action on a `work_items` policy is rejected at load time, before
+  any resource is fetched or acted on, with a clear error - so an unsupported
+  policy never runs partway through. Use the `issues` policy type if you need
+  to comment.
+
+Summaries are also supported (`summarize` and `comment_on_summary`). Any other
+action key (for example `remove_labels`, `mention`, `move`, or `status`) is
+rejected at load time with an error listing the supported actions. On the
+older policy types these keys are applied through comment quick actions, which
+work items do not support yet - rejecting them up front beats silently doing
+nothing.
+
+Actions require a token with sufficient permissions (Planner or Reporter role
+and above). The update endpoint can return success without persisting a change
+when the token lacks permission, so after each update the applied labels and
+assignees are read back from the response and the run raises if the change was
+not reflected.
+
+The `work_items` type works against both project and group sources
+(`--source projects` or `--source groups`). Fetches use the source you run
+against; updates and label lookups target each work item's own namespace,
+because a group run can return work items living in different sub-projects and
+an iid is only unique within its namespace. Project-scoped resource helpers
+(for example `project_path` in templates) likewise resolve the underlying
+project from the work item's namespace.
+
+The `api:` field is not applicable to the `work_items` type, since the type
+already fixes the transport to the Work Items REST API.
+
+#### Field vocabulary
+
+The `work_items` condition names (`type`, `status`, `state`) are deliberately
+cleaner than the `issues` equivalents (`issue_type`, `work_item_status`,
+`state`). This is intentional: they are meant to become the shared vocabulary
+that `issues` converges onto over time (long term, `issues` would alias to
+`work_items` and eventually deprecate in a major version), not a throwaway
+parallel dialect. `state` (`opened` / `closed`) already means the same on both
+types; `status` is new on `work_items` and has no clean one-to-one equivalent
+on `issues` (where it is the prefixed `work_item_status`). Whether the old
+names are carried as aliases or dropped at a major bump is a future decision.
+
 ### Fields
 
 A policy consists of the following fields:

data/lib/gitlab/triage/action/work_item.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../sources/work_items_rest_source'
+require_relative '../url_builders/url_builder'
+require_relative '../resource/label'
+
+module Gitlab
+  module Triage
+    module Action
+      # Applies work_items actions through the Work Items REST API update
+      # endpoint (PATCH) rather than the issues note/quick-action path.
+      #
+      #   - labels    -> features.labels.add_label_ids  (resolved from names)
+      #   - assignees -> features.assignees.assignee_ids (resolved from usernames)
+      #
+      # Missing labels or usernames stop the automation immediately (matching
+      # the labels action behaviour on the issues type) rather than silently
+      # applying nothing - which is especially important because clearing the
+      # assignees array would unassign everyone.
+      class WorkItem < Base
+        AssigneeDoesntExistError = Class.new(StandardError)
+        UpdateNotAppliedError = Class.new(StandardError)
+
+        # The dry run must not touch the network. It prints the requested
+        # label names and assignee usernames rather than resolving them to
+        # ids, mirroring how Comment::Dry avoids network calls.
+        class Dry < WorkItem
+          def act
+            puts "The following work items would be updated for the rule **#{policy.name}**:\n\n"
+
+            super
+          end
+
+          private
+
+          def perform(resource)
+            puts "# #{resource[:web_url]}"
+            puts "Would add labels: #{requested_labels.join(', ')}" if requested_labels.any?
+            puts "Would assign: #{requested_assignees.join(', ')}" if requested_assignees.any?
+            puts "\n"
+          end
+        end
+
+        def act
+          return unless requested_labels.any? || requested_assignees.any?
+
+          policy.resources.each do |resource|
+            perform(resource)
+          end
+        end
+
+        private
+
+        def perform(resource)
+          features = build_features(resource)
+          return if features.empty?
+
+          response = source.update(resource, features)
+
+          verify_applied!(resource, response)
+        end
+
+        def build_features(resource)
+          features = {}
+
+          features[:labels] = { add_label_ids: label_ids_to_add(resource) } if requested_labels.any?
+          features[:assignees] = { assignee_ids: assignee_ids } if requested_assignees.any?
+
+          features
+        end
+
+        def requested_labels
+          @requested_labels ||= Array(policy.actions[:labels])
+        end
+
+        def requested_assignees
+          @requested_assignees ||= Array(policy.actions[:assignees])
+        end
+
+        def source
+          @source ||= Sources::WorkItemsRestSource.new(
+            network: network, options: network.options)
+        end
+
+        # Label ids are namespace-specific, so resolve them against the
+        # resource's own namespace and cache per scope - a group-spanning run
+        # then makes one label lookup per distinct project/group.
+        def label_ids_to_add(resource)
+          scope = source.scope_for(resource)
+
+          @label_ids_by_scope ||= {}
+          @label_ids_by_scope[scope] ||= resolve_label_ids(requested_labels, scope)
+        end
+
+        def assignee_ids
+          @assignee_ids ||= resolve_assignee_ids(requested_assignees)
+        end
+
+        # Resolve every requested label name to an id. Any name that does not
+        # resolve raises, so the run stops instead of PATCHing a partial (or
+        # empty) label set.
+        def resolve_label_ids(names, scope)
+          return [] if names.empty?
+
+          by_name = network.query_api(labels_url(scope)).index_by { |label| label[:name] }
+
+          names.map do |name|
+            label = by_name[name]
+            raise Resource::Label::LabelDoesntExistError, "Label `#{name}` doesn't exist!" unless label
+
+            label[:id]
+          end
+        end
+
+        # Resolve every requested username to an id. A missing username raises
+        # rather than being dropped, because an empty assignee_ids array would
+        # clear all assignees on the work item.
+        def resolve_assignee_ids(usernames)
+          return [] if usernames.empty?
+
+          usernames.map do |username|
+            id = resolve_user_id(username)
+            raise AssigneeDoesntExistError, "User `#{username}` doesn't exist!" unless id
+
+            id
+          end
+        end
+
+        def resolve_user_id(username)
+          users = network.query_api(users_url(username))
+
+          users.first&.dig(:id)
+        end
+
+        # The Work Items REST update endpoint can return success without
+        # persisting a change when the token lacks permission. The response
+        # echoes the resulting widgets, so confirm the requested ids landed and
+        # raise otherwise rather than reporting a silent no-op as success.
+        def verify_applied!(resource, response)
+          verify_labels_applied!(resource, response) if requested_labels.any?
+          verify_assignees_applied!(resource, response) if requested_assignees.any?
+        end
+
+        def verify_labels_applied!(resource, response)
+          applied_ids = [*response.dig(:features, :labels, :labels)].pluck(:id)
+          missing = label_ids_to_add(resource) - applied_ids
+          return if missing.empty?
+
+          raise UpdateNotAppliedError,
+            "Labels were not applied to #{resource[:web_url]}; the token may lack permission."
+        end
+
+        def verify_assignees_applied!(resource, response)
+          applied_ids = [*response.dig(:features, :assignees)].pluck(:id)
+          missing = assignee_ids - applied_ids
+          return if missing.empty?
+
+          raise UpdateNotAppliedError,
+            "Assignees were not applied to #{resource[:web_url]}; the token may lack permission."
+        end
+
+        def labels_url(scope)
+          scope_source, scope_id = scope
+
+          UrlBuilders::UrlBuilder.new(
+            network_options: network.options,
+            source: scope_source,
+            source_id: scope_id,
+            resource_type: 'labels',
+            params: { per_page: 100 }
+          ).build
+        end
+
+        def users_url(username)
+          options = network.options
+
+          "#{options.host_url}/api/#{options.api_version}/users?username=#{CGI.escape(username)}"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/action.rb

@@ -6,6 +6,7 @@ require_relative 'action/comment_on_summary'
 require_relative 'action/issue'
 require_relative 'action/delete'
 require_relative 'action/work_item_status'
+require_relative 'action/work_item'
 
 module Gitlab
   module Triage
@@ -13,18 +14,34 @@ module Gitlab
       def self.process(policy:, **args)
         policy.validate!
 
-        [
-          [Summarize, policy.summarize?],
-          [Comment, policy.comment?],
-          [CommentOnSummary, policy.comment_on_summary?],
-          [Issue, policy.issue?],
-          [Delete, policy.delete?],
-          [WorkItemStatus, policy.work_item_status?]
-        ].each do |action, active|
+        actions_for(policy).each do |action, active|
           act(action: action, policy: policy, **args) if active
         end
       end
 
+      # Work items are fetched and updated through the Work Items REST API,
+      # which does not share the issues note/quick-action write path. Their
+      # actions (assign, label, comment) are handled by a dedicated action
+      # instead of the note-based Comment action.
+      def self.actions_for(policy)
+        if policy.type == 'work_items'
+          [
+            [Summarize, policy.summarize?],
+            [WorkItem, policy.work_item?],
+            [CommentOnSummary, policy.comment_on_summary?]
+          ]
+        else
+          [
+            [Summarize, policy.summarize?],
+            [Comment, policy.comment?],
+            [CommentOnSummary, policy.comment_on_summary?],
+            [Issue, policy.issue?],
+            [Delete, policy.delete?],
+            [WorkItemStatus, policy.work_item_status?]
+          ]
+        end
+      end
+
       def self.act(action:, dry:, **args)
         klass =
           if dry

data/lib/gitlab/triage/api_observability.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Gitlab
+  module Triage
+    module APIObservability
+      class Tracker
+        PAGINATION_PARAMS = %w[page per_page].freeze
+
+        attr_reader :calls, :resources_fetched
+
+        def initialize
+          @calls = Hash.new(0)
+          @resources_fetched = 0
+          @rate_limit_waits = 0
+          @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def record(method, url, resource_count: 0)
+          @calls["#{method} #{normalize_endpoint(url)}"] += 1
+          @resources_fetched += resource_count
+        end
+
+        def record_rate_limit_wait
+          @rate_limit_waits += 1
+        end
+
+        def total
+          @calls.values.sum
+        end
+
+        def print_summary
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+
+          puts "\n"
+          puts '=' * 70
+          puts '  API Call Summary'
+          puts '=' * 70
+          puts "  Total HTTP requests:  #{total}"
+          puts "  Resources fetched:    #{@resources_fetched}"
+          puts "  Rate limit waits:     #{@rate_limit_waits}"
+          puts "  Elapsed time:         #{elapsed.round(1)}s"
+          puts '-' * 70
+
+          @calls.sort_by { |_, count| -count }.each do |endpoint, count|
+            puts "  #{count.to_s.rjust(5)}x  #{endpoint}"
+          end
+
+          puts '=' * 70
+        end
+
+        private
+
+        def normalize_endpoint(url)
+          uri = URI.parse(url)
+          path = uri.path
+                    .sub(%r{/api/v\d+}, '')
+                    .sub(%r{/projects/[^/]+}, '/projects/:id')
+                    .sub(%r{/groups/[^/]+}, '/groups/:id')
+                    .gsub(%r{/\d+(/|\z)}, '/:id\1')
+
+          query_keys = (URI.decode_www_form(uri.query || '').map(&:first) - PAGINATION_PARAMS).sort
+
+          path += "?#{query_keys.join('&')}" if query_keys.any?
+          path
+        rescue URI::InvalidURIError
+          url
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/engine.rb

@@ -15,6 +15,7 @@ require_relative 'filters/assignee_member_conditions_filter'
 require_relative 'filters/discussions_conditions_filter'
 require_relative 'filters/ruby_conditions_filter'
 require_relative 'filters/work_item_status_conditions_filter'
+require_relative 'filters/work_item_date_conditions_filter'
 require_relative 'limiters/date_field_limiter'
 require_relative 'action'
 require_relative 'policies/rule_policy'
@@ -31,7 +32,11 @@ require_relative 'rest_api_network'
 require_relative 'network_adapters/httparty_adapter'
 require_relative 'network_adapters/graphql_adapter'
 require_relative 'graphql_queries/query_builder'
+require_relative 'sources/work_items_rest_source'
+require_relative 'validators/params_validator'
+require_relative 'validators/policy_validator'
 require_relative 'ui'
+require_relative 'api_observability'
 
 module Gitlab
   module Triage
@@ -45,7 +50,8 @@ module Gitlab
         date: {
           'branches' => Filters::BranchDateFilter,
           'issues' => Filters::IssueDateConditionsFilter,
-          'merge_requests' => Filters::MergeRequestDateConditionsFilter
+          'merge_requests' => Filters::MergeRequestDateConditionsFilter,
+          'work_items' => Filters::WorkItemDateConditionsFilter
         },
         protected: Filters::BranchProtectedFilter,
         assignee_member: Filters::AssigneeMemberConditionsFilter,
@@ -62,7 +68,8 @@ module Gitlab
       DEFAULT_GRAPHQL_ADAPTER = Gitlab::Triage::NetworkAdapters::GraphqlAdapter
       ALLOWED_STATE_VALUES = {
         issues: %w[opened closed],
-        merge_requests: %w[opened closed merged]
+        merge_requests: %w[opened closed merged],
+        work_items: %w[opened closed]
       }.with_indifferent_access.freeze
       MILESTONE_TIMEBOX_VALUES = %w[none any upcoming started].freeze
       ITERATION_SELECTION_VALUES = %w[none any].freeze
@@ -88,22 +95,30 @@ module Gitlab
       end
 
       def perform
+        Validators::PolicyValidator.new(resource_rules).validate!
+
         puts "Performing a dry run.\n\n" if options.dry_run
 
-        puts Gitlab::Triage::UI.header("Triaging the `#{options.source_id}` #{options.source.singularize}", char: '=')
-        puts
+        unless options.quiet
+          puts Gitlab::Triage::UI.header("Triaging the `#{options.source_id}` #{options.source.singularize}", char: '=')
+          puts
+        end
 
         resource_rules.each do |resource_type, policy_definition|
           next unless right_resource_type_for_resource_option?(resource_type)
 
           assert_epic_rule!(resource_type)
 
-          puts Gitlab::Triage::UI.header("Processing summaries & rules for #{resource_type}", char: '-')
-          puts
+          unless options.quiet
+            puts Gitlab::Triage::UI.header("Processing summaries & rules for #{resource_type}", char: '-')
+            puts
+          end
 
           process_summaries(resource_type, policy_definition[:summaries])
           process_rules(resource_type, policy_definition[:rules])
         end
+
+        tracker.print_summary if options.summary
       end
 
       def network
@@ -118,6 +133,11 @@ module Gitlab
         @graphql_network ||= GraphqlNetwork.new(graphql_network_adapter)
       end
 
+      def work_items_source
+        @work_items_source ||= Sources::WorkItemsRestSource.new(
+          network: network, options: options, per_page: per_page)
+      end
+
       private
 
       def assert_options!
@@ -185,7 +205,7 @@ module Gitlab
         resource_reference = options.resource_reference
 
         case resource_type
-        when 'issues'
+        when 'issues', 'work_items'
           resource_reference.start_with?('#')
         when 'merge_requests'
           resource_reference.start_with?('!')
@@ -204,12 +224,16 @@ module Gitlab
         @resource_rules ||= policies.delete(:resource_rules) { {} }
       end
 
+      def tracker
+        @tracker ||= options.summary ? APIObservability::Tracker.new : nil
+      end
+
       def network_adapter
-        @network_adapter ||= @network_adapter_class.new(options)
+        @network_adapter ||= @network_adapter_class.new(options, tracker: tracker)
       end
 
       def graphql_network_adapter
-        @graphql_network_adapter ||= @graphql_network_adapter_class.new(options)
+        @graphql_network_adapter ||= @graphql_network_adapter_class.new(options, tracker: tracker)
       end
 
       def rule_conditions(rule)
@@ -310,8 +334,10 @@ module Gitlab
       #
       # @return [nil]
       def process_summary(resource_type, summary_definition)
-        puts Gitlab::Triage::UI.header("Processing summary: **#{summary_definition[:name]}**", char: '~')
-        puts
+        unless options.quiet
+          puts Gitlab::Triage::UI.header("Processing summary: **#{summary_definition[:name]}**", char: '~')
+          puts
+        end
 
         summary_parts_for_rules(resource_type, summary_definition[:rules]) do |summary_resources|
           policy = Policies::SummaryPolicy.new(
@@ -365,7 +391,7 @@ module Gitlab
       #
       # @return [nil]
       def resources_for_rule(resource_type, rule_definition, in_summary: false)
-        puts Gitlab::Triage::UI.header("Gathering resources for rule: **#{rule_definition[:name]}**", char: '-')
+        puts Gitlab::Triage::UI.header("Gathering resources for rule: **#{rule_definition[:name]}**", char: '-') unless options.quiet
 
         # Skip resource fetching for custom type rules
         if rule_definition[:type] == 'custom'
@@ -373,7 +399,7 @@ module Gitlab
             raise ArgumentError, "type: custom can only be used in summary rules, not in top-level rules (rule: #{rule_definition[:name]})"
           end
 
-          puts "\n* Skipping resource fetch for custom type rule"
+          puts "\n* Skipping resource fetch for custom type rule" unless options.quiet
           yield(PoliciesResources::RuleResources.new([]), {})
           return
         end
@@ -391,14 +417,23 @@ module Gitlab
           # In some filters/actions we want to know which resource type it is
           attach_resource_type(resources, resource_type)
 
-          puts "\n\n* Found #{resources.count} resources..."
-          print "* Filtering resources..."
+          unless options.quiet
+            puts "\n\n* Found #{resources.count} resources..."
+            print "* Filtering resources..."
+          end
+
           resources = filter_resources(resources, expanded_conditions)
-          puts "\n* Total after filtering: #{resources.count} resources"
-          print "* Limiting resources..."
+
+          unless options.quiet
+            puts "\n* Total after filtering: #{resources.count} resources"
+            print "* Limiting resources..."
+          end
+
           resources = limit_resources(resources, rule_limits(rule_definition))
-          puts "\n* Total after limiting: #{resources.count} resources"
-          puts
+          unless options.quiet
+            puts "\n* Total after limiting: #{resources.count} resources"
+            puts
+          end
 
           resources = sanitize_resources(resources)
 
@@ -407,6 +442,8 @@ module Gitlab
       end
 
       def fetch_resources(resource_type, expanded_conditions, rule_definition)
+        return fetch_work_items(expanded_conditions) if resource_type == 'work_items'
+
         resources = []
 
         if rule_definition[:api] == 'graphql'
@@ -454,6 +491,21 @@ module Gitlab
         resources
       end
 
+      def fetch_work_items(expanded_conditions)
+        conditions = expanded_conditions.dup
+        conditions[:iids] = options.resource_reference[1..] if options.resource_reference
+
+        # The work_items path bypasses build_get_url, so validate `state` here
+        # the same way the URL builders do for the other resource types.
+        if conditions[:state]
+          ParamsValidator.new(
+            [{ name: 'state', type: String, values: ALLOWED_STATE_VALUES[:work_items] }],
+            { 'state' => conditions[:state] }).validate!
+        end
+
+        work_items_source.list(conditions)
+      end
+
       def attach_resource_type(resources, resource_type)
         resources.each { |resource| resource[:type] = resource_type }
       end
@@ -470,7 +522,7 @@ module Gitlab
           policy: policy,
           network: network,
           dry: options.dry_run)
-        puts
+        puts unless options.quiet
       end
 
       def filter_resources(resources, conditions)

data/lib/gitlab/triage/filters/work_item_date_conditions_filter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'issue_date_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class WorkItemDateConditionsFilter < IssueDateConditionsFilter
+      end
+    end
+  end
+end